@knowvah/dot-engine 2.3.1 → 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

@@ -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;
 }
@@ -377,7 +378,7 @@ function routeFaithfulSidePort(e: GraphEdge, g: Graph): boolean {
   // 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);

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

@@ -126,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.
@@ -152,8 +152,8 @@ 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

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

@@ -21,11 +21,10 @@ import { dotRank } from './rank.js';
 import { dotMincross } from './mincross.js';
 import { dotPosition } from './position.js';
 import { dotSameports } from './sameport.js';
-import { dotSplines_, swapEndsP, swapEdgeSpline, EDGETYPE_SPLINE } from './splines.js';
+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, routePolylines } from '../../common/splines-routespl.js';
 import { addBox, resolvePort } from '../../common/splines-path-shared.js';
 import { TOP, BOTTOM, FLATEDGE } from '../../common/splines-constants.js';
 import {
@@ -421,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
@@ -568,31 +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 (as the regular path).
- *
- * @see lib/dotgen/dotsplines.c:make_flat_edge (cnt=1, non-adjacent spline)
- */
-export function routeFlatEdgeFaithful(g: Graph, e: Edge, et: number): 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, hlast] = [tend.boxes[tend.boxn - 1], hend.boxes[hend.boxn - 1]];
-  const mid = (bottom ? bottomBoxes : topBoxes)(tlast, hlast, stepx, stepy, stepy);
-  assembleFlatPath(P, tend, hend, mid);
-  // @see lib/dotgen/dotsplines.c:1603-1607
-  return et === EDGETYPE_SPLINE ? routeSplines(P) : routePolylines(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.

package/src/layout/dot/splines.ts

@@ -434,7 +434,7 @@ export function resetRW(g: Graph): void {
 }
 
 /**
- * splines=ortho dispatch — mirror dotsplines.c:251-259: resetRW, run the
+ * splines=ortho dispatch — mirror dotsplines.c:251-266: resetRW, run the
  * orthoEdges pipeline (before mark_lowclusters), then the finish semantics
  * (skip routesplinesterm — not ported in TS; set edgeLabelsDone; return 0).
  * Edge-label sub-case is T2.
@@ -443,15 +443,15 @@ export function resetRW(g: Graph): void {
 function orthoDispatch(g: Graph): number {
   resetRW(g);
   // C: if (GD_has_labels(g->root) & EDGE_LABEL) { setEdgeLabelPos(g);
-  //      orthoEdges(g,true); } else orthoEdges(g,false);
+  //      rc = orthoEdges(g,true); } else rc = orthoEdges(g,false);
   // orthoEdges itself warns + downgrades useLbls (ortho/index.ts) — C never
   // routes edges around labels (ADR-2). We only POSITION the labels here.
+  let rc: number;
   if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
     setEdgeLabelPos(g);
-    dispatchOrthoEdges(g, true);
-  } else {
-    dispatchOrthoEdges(g, false);
-  }
+    rc = dispatchOrthoEdges(g, true);
+  } else rc = dispatchOrthoEdges(g, false);
+  if (rc !== 0) return rc; // 16.1 8fd4b59ef: skip port labels, EdgeLabelsDone
   // C's `goto finish` lands ON the port-label placement block
   // (dotsplines.c:436-458): head/tail labels with labelangle/labeldistance
   // are placed via place_portlabel for ortho too. Skipping this left the

package/src/layout/neato/constraint-adjust.ts

@@ -26,6 +26,7 @@ import { Edge } from '../../model/edge.js';
 import type { EdgeList } from '../../model/nodeInfo.js';
 import { DtBag } from '../../cdt/index.js';
 import { cround } from '../../common/arith.js';
+import { d2i } from '../../util/math.js';
 import { rank } from '../dot/ns.js';
 import { elistAppend } from '../dot/fastgr.js';
 import { nodesInSeq } from '../dot/decomp.js';
@@ -385,8 +386,13 @@ function overlaps(p: Nitem[]): boolean {
   return false;
 }
 
-/** @see lib/neatogen/constraint.c:initItem */
-function initItem(n: Node, margin: ExpandT): Nitem {
+/**
+ * Additive margins convert with d2i (clamp to INT_MIN..INT_MAX, else
+ * truncate) since graphviz 16.1 (13e5f6ce8). Exported for tests.
+ * @see lib/neatogen/constraint.c:initItem
+ * @internal
+ */
+export function initItem(n: Node, margin: ExpandT): Nitem {
   const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH);
   const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH);
   const width = n.info.width ?? 0;
@@ -394,8 +400,8 @@ function initItem(n: Node, margin: ExpandT): Nitem {
   let w2: number;
   let h2: number;
   if (margin.doAdd) {
-    w2 = Math.trunc(SCALE * (cround((width / 2.0) * POINTS_PER_INCH) + margin.x));
-    h2 = Math.trunc(SCALE * (cround((height / 2.0) * POINTS_PER_INCH) + margin.y));
+    w2 = d2i(SCALE * (cround((width / 2.0) * POINTS_PER_INCH) + margin.x));
+    h2 = d2i(SCALE * (cround((height / 2.0) * POINTS_PER_INCH) + margin.y));
   } else {
     w2 = cround(margin.x * SCALE2 * width * POINTS_PER_INCH);
     h2 = cround(margin.y * SCALE2 * height * POINTS_PER_INCH);

package/src/layout/neato/multispline.ts

@@ -17,6 +17,7 @@ import type { Graph } from '../../model/graph.js';
 import type { Point } from '../../pathplan/types.js';
 import type { SplineInfo } from '../../common/types.js';
 import { wind } from '../../pathplan/visibility.js';
+import { fma } from '../../common/fma.js';
 import { shortestPath } from '../../pathplan/shortest.js';
 import { routeSpline, makePolyline } from '../../pathplan/index.js';
 import type { Edge as PEdge } from '../../pathplan/types.js';
@@ -85,10 +86,12 @@ function raySegIntersect(v: Point, w: Point, a: Point, b: Point): Point | null {
   const mv = { x: w.x - v.x, y: w.y - v.y };
   const lv = { x: b.x - a.x, y: b.y - a.y };
   const ln = { x: -lv.y, y: lv.x }; // perp
-  const lc = -(ln.x * a.x + ln.y * a.y);
-  const dt = ln.x * mv.x + ln.y * mv.y;
+  // libgvc's line_intersect fuses the first product of each dot():
+  // fmsub(lv.y, p.x, lv.x·p.y). The final a - s·mv is NOT fused.
+  const lc = -fma(ln.x, a.x, ln.y * a.y);
+  const dt = fma(ln.x, mv.x, ln.y * mv.y);
   if (Math.abs(dt) < SMALL) return null;
-  const s = (ln.x * v.x + ln.y * v.y + lc) / dt;
+  const s = (fma(ln.x, v.x, ln.y * v.y) + lc) / dt;
   return { x: v.x - s * mv.x, y: v.y - s * mv.y };
 }
 
@@ -115,6 +118,19 @@ function ctrlPtIdx(v: Point, ps: Point[]): number {
 
 const SEP = 15;
 
+/** v + 100·(cos, sin), fused like the binary's fmadd. @see multispline.c:mkCtrlPts */
+function bisectorTarget(v: Point, cosTheta: number, sinTheta: number): Point {
+  return { x: fma(cosTheta, 100, v.x), y: fma(sinTheta, 100, v.y) };
+}
+
+/** DIST(p, q) = sqrt(DIST2), the sum of squares fused (fmadd(dx, dx, dy·dy)) —
+ * not hypot. @see lib/common/geom.h:DIST */
+function distFused(p: Point, q: Point): number {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return Math.sqrt(fma(dx, dx, dy * dy));
+}
+
 /**
  * mult points on the bisector ray at corridor vertex v, spaced ≤ SEP,
  * ordered by side (s = index after which vertices are on the far side).
@@ -129,31 +145,32 @@ function mkCtrlPts(
   const theta = bisect(prev, v, nxt);
   let sinTheta = Math.sin(theta);
   let cosTheta = Math.cos(theta);
-  let w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+  // The binary fuses v + 100·cos/sin and v + (i·sep)·cos/sin (fmadd/fmla).
+  let w = bisectorTarget(v, cosTheta, sinTheta);
   if (idx > s) {
     if (wind(prev, v, w) !== 1) {
       sinTheta *= -1;
       cosTheta *= -1;
-      w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+      w = bisectorTarget(v, cosTheta, sinTheta);
     }
   } else if (wind(prev, v, w) !== -1) {
     sinTheta *= -1;
     cosTheta *= -1;
-    w = { x: v.x + 100 * cosTheta, y: v.y + 100 * sinTheta };
+    w = bisectorTarget(v, cosTheta, sinTheta);
   }
   const q = triPoint(trip, idx, v, w);
   if (q === null) return null;
 
-  const d = Math.hypot(q.x - v.x, q.y - v.y);
+  const d = distFused(q, v);
   const sep = d >= mult * SEP ? SEP : d / mult;
   const ps = new Array<Point>(mult);
   if (idx < s) {
     for (let i = 0; i < mult; i++) {
-      ps[i] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[i] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   } else {
     for (let i = 0; i < mult; i++) {
-      ps[mult - i - 1] = { x: v.x + i * sep * cosTheta, y: v.y + i * sep * sinTheta };
+      ps[mult - i - 1] = { x: fma(i * sep, cosTheta, v.x), y: fma(i * sep, sinTheta, v.y) };
     }
   }
   return ps;