@knowvah/dot-engine 2.3.0 → 2.4.0

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;

package/src/layout/neato/splines.ts

@@ -19,6 +19,7 @@ import type { Edge } from '../../model/edge.js';
 import type { Point } from '../../model/geom.js';
 import type { SplineInfo, PolygonT, TextlabelT } from '../../common/types.js';
 import { polygonOutlineRing } from '../../common/poly-sizing.js';
+import { fma, fms } from '../../common/fma.js';
 import { ShapeKind } from '../../common/types.js';
 import type { ExpandT } from './sep-factor.js';
 import { esepFactor } from './sep-factor.js';
@@ -127,12 +128,11 @@ class ObstacleHelper {
 
 /** Slope of the ellipse tangent at p. @see neatosplines.c:ellipse_tangent_slope */
 function ellipseTangentSlope(a: number, b: number, p: Point): number {
-  const signY = p.y >= 0 ? 1 : -1;
-  return (-signY * (b * p.x)) / (a * Math.sqrt(a * a - p.x * p.x));
+  const signY = p.y >= 0 ? 1 : -1; // radicand: the binary fuses a*a (fmla)
+  return (-signY * (b * p.x)) / (a * Math.sqrt(fma(a, a, -(p.x * p.x))));
 }
 
-/** Corner i of an nsides-gon circumscribed about the ellipse (a, b).
- * @see neatosplines.c:circumscribed_polygon_corner_about_ellipse */
+/** Corner i of an nsides-gon about ellipse (a, b). @see neatosplines.c:circumscribed_polygon_corner_about_ellipse */
 function circumscribedCorner(a: number, b: number, i: number, nsides: number): Point {
   const angle0 = (2 * Math.PI * (i - 0.5)) / nsides;
   const angle1 = (2 * Math.PI * (i + 0.5)) / nsides;
@@ -140,9 +140,9 @@ function circumscribedCorner(a: number, b: number, i: number, nsides: number): P
   const p1 = { x: a * Math.cos(angle1), y: b * Math.sin(angle1) };
   const m0 = ellipseTangentSlope(a, b, p0);
   const m1 = ellipseTangentSlope(a, b, p1);
-  // line_intersection of the two tangents.
-  const x = (m0 * p0.x - p0.y - m1 * p1.x + p1.y) / (m0 - m1);
-  const y = p0.y + m0 * (x - p0.x);
+  // line_intersection, contracted as the binary: fnmsub, fmls, +; y = fmadd.
+  const x = (fms(p1.x, m1, fma(m0, p0.x, -p0.y)) + p1.y) / (m0 - m1);
+  const y = fma(m0, x - p0.x, p0.y);
   return { x, y };
 }
 

package/src/layout/pack/poly-place.ts

@@ -19,6 +19,7 @@ import type { Edge } from '../../model/edge.js';
 import type { PackInfo } from './types.js';
 import { PackMode } from './types.js';
 import { cround } from '../../common/arith.js';
+import { d2i } from '../../util/math.js';
 import { gvQsort } from '../../util/bsd-qsort.js';
 
 /** Max. avg. polyomino size. @see lib/pack/pack.c:C */
@@ -78,7 +79,10 @@ export function computeStep(bbs: Box[], margin: number): number {
     c -= W * H;
   }
   const r = Math.sqrt(b * b - 4 * a * c);
-  const root = Math.trunc((-b + r) / (2 * a));
+  // C `root = (int)l1`: the native arm64 build converts with `fcvtzs w`, which
+  // saturates at INT_MAX (objdump of libgvc `_computeStep`). Only graphs with
+  // extreme coordinates reach it (1314: l1 = 7.4e10 → step 2147483647).
+  const root = d2i((-b + r) / (2 * a));
   return root === 0 ? 1 : root;
 }
 
@@ -289,7 +293,10 @@ function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): boolean {
   }
   const bb = ctx.bbs[info.index]!;
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
-  ctx.places[info.index] = { x: ctx.step * x - LL.x, y: ctx.step * y - LL.y };
+  // C `step * x` is int * int: a 32-bit `mul w` that wraps before the result
+  // is widened to double (objdump of libgvc `_fits`). Matters only once
+  // computeStep has saturated at INT_MAX.
+  ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
   for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
   return true;
 }

package/src/layout/sfdp/__fixtures__/pcp-rotate-native.ts

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * pcp_rotate input/output pairs dumped from the native graphviz 16.1.0
+ * build (LTO on, Apple clang 21, arm64): the instrumented
+ * multilevel_spring_electrical_embedding printed x[] with %a immediately
+ * before and after the inlined pcp_rotate call (sfdp layout of each input).
+ * The instrumented plugin's disassembly of the inlined body was identical to
+ * the oracle's and its xdot for tests/42.dot was byte-identical.
+ *
+ * @see lib/sfdpgen/spring_electrical.c:pcp_rotate
+ */
+
+/** One native pcp_rotate call (dim = 2): coordinates in and out. */
+export interface PcpCase {
+  readonly n: number;
+  readonly input: readonly number[];
+  readonly output: readonly number[];
+}
+
+/** tests/42.dot (n = 25: 24 unfused main-loop points + 1 fused tail point). */
+export const PCP_42: PcpCase = {
+  n: 25,
+  input: [
+    3.5872483107422566, -12.377777121200412, 3.4715918522980727,
+    -12.918978548323624, 4.121783883411746, -12.91831647385274,
+    3.795604961681946, -12.02670434921042, 3.475187937840741,
+    -12.116509880628376, 3.176953710079423, -11.474322726281912,
+    3.223320716000219, -12.50190058190682, 3.9427450081150517,
+    -12.609361218577487, 2.9320923020663012, -12.08466407155544,
+    2.647834118844372, -12.484128275830983, 2.485503508198676,
+    -12.052368284631822, 2.454104738007288, -11.543163215115078,
+    3.965624072051866, -12.301668238922174, 3.272695018831133,
+    -12.293622724126323, 4.277294098336774, -12.52763434032553,
+    2.6567536665021607, -11.78672436299522, 2.9194126389126986,
+    -10.94953631613356, 2.5489751513175936, -10.86946489644661,
+    2.6733650330275274, -11.224528211868394, 3.048965000467677,
+    -11.637154070809292, 4.317960366069153, -12.028182724742415,
+    3.1405903774739743, -10.735347387936093, 3.517649553441379,
+    -11.59828957557804, 2.889150038336242, -11.393037327449802,
+    3.8184483813156236, -11.736128083787474,
+  ],
+  output: [
+    -0.5304877806920583, 0.08366486993416244, -0.8552660176992705,
+    0.5317658606344066, -1.289862780722194, 0.048158820532294325,
+    -0.409028142995645, -0.30609421159466693, -0.26135016442439085,
+    -0.007894082007798424, 0.41543462009487314, -0.21600547347691734,
+    -0.3791958356150653, 0.4371626422995346, -0.9404677592737167,
+    -0.02553912799220554, 0.1257378673267193, 0.374375300532583,
+    0.019109087106747153, 0.8529196228841546, 0.44858083486899103,
+    0.6846284019992013, 0.8479871604816006, 0.36721656754478493,
+    -0.7271280985453075, -0.24843957764647775, -0.257462324530711,
+    0.2610989035548756, -1.1036058128568746, -0.3288349437729226,
+    0.5313880036167653, 0.37960990645275156, 0.9777471494560837,
+    -0.37579533215854694, 1.285134511761471, -0.1541010066529222,
+    0.9380455904287646, -0.00893874806544041, 0.38007922650162834,
+    -0.01193403330818422, -0.7596711077227419, -0.693272291261024,
+    0.988907593770146, -0.6834833778804641, 0.09533034350091935,
+    -0.38622500677079324, 0.668428062586742, -0.05652949538534024,
+    -0.2083842264234602, -0.5175141883950642,
+  ],
+};
+
+/** `graph { a -- b -- c -- d -- e -- f -- g; a -- d; c -- g }` (n = 7: 4 unfused + 3 fused). */
+export const PCP_N7: PcpCase = {
+  n: 7,
+  input: [
+    -15.236266874412502, -14.141759136203413, -14.362447295439736,
+    -14.495631475674346, -14.72475387596594, -15.55293197670535,
+    -15.713464401249913, -15.151793337403825, -16.37705062226656,
+    -16.145225064687455, -15.922726903476539, -17.08665871053711,
+    -14.941732868825685, -16.728142530138104,
+  ],
+  output: [
+    1.3982174906911033, 0.47136487209612654, 1.3990421407369296,
+    -0.47138939556383713, 0.2831108329282356, -0.533419420756337,
+    0.28286219933551654, 0.5335672937482661, -0.887224005839827,
+    0.7747136019415551, -1.5886065363823616, -0.0003798742551679708,
+    -0.887402121469613, -0.7744570772106122,
+  ],
+};
+
+/** `graph { a -- b; b -- c; a -- c [len=2] }` (n = 3: no main loop, all fused). */
+export const PCP_N3: PcpCase = {
+  n: 3,
+  input: [
+    12.264744691446909, -0.43911661110249495, 13.621642438404422,
+    -0.3215742583017034, 12.841756307969007, 0.7944196810068545,
+  ],
+  output: [
+    -0.7758786283883479, -0.1280321647860694, 0.4988649924591231,
+    -0.6076324165676953, 0.277013635929228, 0.7356645813537631,
+  ],
+};

package/src/layout/sfdp/spring-driver.ts

@@ -84,8 +84,46 @@ export function powerLawGraph(A: SpMatrix): boolean {
   return mask[1]! > 0.8 * max && mask[1]! > 0.3 * m;
 }
 
+/**
+ * Width of the vectorised main loop clang emits for pcp_rotate's
+ * covariance accumulation once LTO inlines it (dim == 2 constant).
+ * @see lib/sfdpgen/spring_electrical.c:pcp_rotate (16.1, 630465f82)
+ */
+const PCP_COVARIANCE_LANES = 4;
+
+/**
+ * The covariance accumulation `y[dim*k+l] += x[i*dim+k]*x[i*dim+l]`, with
+ * the native 16.1 build's FMA contraction. 630465f82 made pcp_rotate
+ * static, so LTO inlines it into multilevel_spring_electrical_embedding
+ * and vectorises this loop 4 points at a time: the main loop multiplies
+ * and adds separately (fmul.2d + fadd.2d, two roundings) and only the
+ * scalar tail over the last n % 4 points is fused (fmla.2d/fmadd).
+ * Accumulation order is the C order in both parts. (The 15.x out-of-line
+ * pcp_rotate fused every point.)
+ * @see lib/sfdpgen/spring_electrical.c:pcp_rotate
+ */
+function pcpCovariance(n: number, dim: number, x: number[], y: number[]): void {
+  const nUnfused = n - (n % PCP_COVARIANCE_LANES);
+  for (let i = 0; i < n; i++) {
+    for (let k = 0; k < dim; k++) {
+      for (let l = 0; l < dim; l++) {
+        const a = x[i * dim + k]!;
+        const b = x[i * dim + l]!;
+        const acc = y[dim * k + l]!;
+        y[dim * k + l] = i < nUnfused ? acc + a * b : fma(a, b, acc);
+      }
+    }
+  }
+}
+
 /**
  * Principal-component rotation about the centroid.
+ *
+ * FMA contraction mirrors the native 16.1 build (objdump of the inlined
+ * body): the covariance loop per pcpCovariance; the eigenvector radicand
+ * fuses its y0*y0, -2*y0*y3 and y3*y3 terms (4*y1*y1 is rounded first);
+ * `1 + axis0*axis0` is fused; each rotated coordinate fuses its first
+ * product (x0 = fma(x, a0, y*a1), x1 = fma(-x, a1, y*a0)).
  * @see lib/sfdpgen/spring_electrical.c:pcp_rotate
  */
 export function pcpRotate(n: number, dim: number, x: number[]): void {
@@ -98,26 +136,20 @@ export function pcpRotate(n: number, dim: number, x: number[]): void {
   for (let i = 0; i < n; i++) {
     for (let k = 0; k < dim; k++) x[dim * i + k]! -= center[k]!;
   }
-  for (let i = 0; i < n; i++) {
-    for (let k = 0; k < dim; k++) {
-      for (let l = 0; l < dim; l++) {
-        y[dim * k + l] = fma(x[i * dim + k]!, x[i * dim + l]!, y[dim * k + l]!);
-      }
-    }
-  }
+  pcpCovariance(n, dim, x, y);
   const axis = [0, 1];
   if (y[1] !== 0) {
-    axis[0] = -(-y[0]! + y[3]! -
-      Math.sqrt(y[0]! * y[0]! + 4 * y[1]! * y[1]! - 2 * y[0]! * y[3]! + y[3]! * y[3]!))
-      / (2 * y[1]!);
+    const radicand = fma(y[3]!, y[3]!,
+      fma(-2 * y[0]!, y[3]!, fma(y[0]!, y[0]!, 4 * y[1]! * y[1]!)));
+    axis[0] = -(-y[0]! + y[3]! - Math.sqrt(radicand)) / (2 * y[1]!);
     axis[1] = 1;
   }
-  const dist = Math.sqrt(1 + axis[0]! * axis[0]!);
+  const dist = Math.sqrt(fma(axis[0]!, axis[0]!, 1));
   axis[0] = axis[0]! / dist;
   axis[1] = axis[1]! / dist;
   for (let i = 0; i < n; i++) {
-    const x0 = x[dim * i]! * axis[0]! + x[dim * i + 1]! * axis[1]!;
-    const x1 = -x[dim * i]! * axis[1]! + x[dim * i + 1]! * axis[0]!;
+    const x0 = fma(x[dim * i]!, axis[0]!, x[dim * i + 1]! * axis[1]!);
+    const x1 = fma(-x[dim * i]!, axis[1]!, x[dim * i + 1]! * axis[0]!);
     x[dim * i] = x0;
     x[dim * i + 1] = x1;
   }

package/src/ortho/index.ts

@@ -9,7 +9,7 @@
 
 import type {
   OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint,
-  Route,
+  Route, Maze, SGraph,
 } from "./types.js";
 import type { ClipAndInstallFn } from "./types.js";
 import { mkMaze, freeMaze } from "./maze.js";
@@ -67,7 +67,7 @@ function edgeCmp(a: EdgePair, b: EdgePair): number {
 function buildSpline(
   e: OrthoEdge,
   rte: Route,
-  mp: ReturnType<typeof mkMaze>,
+  mp: Maze,
 ): OrthoPoint[] {
   const pts: OrthoPoint[] = [];
   if (rte.segs.length === 0) return pts;
@@ -118,17 +118,31 @@ function buildSpline(
 
 // ─── orthoEdges ───────────────────────────────────────────────────────────────
 
+/** Ensure the two dummy search nodes (sn, dn) exist past the maze's nodes. */
+function ensureDummyNodes(sg: SGraph, gstart: number): void {
+  while (sg.nodes.length < gstart + 2) {
+    sg.nodes.push({
+      nVal: 0, nIdx: 0, nDad: null, nEdge: null,
+      nAdj: 0, saveNAdj: 0, cells: [null, null],
+      adjEdgeList: [], index: sg.nodes.length, isVert: false, x: 0, y: 0,
+    });
+  }
+}
+
 /**
  * For edges without position information, construct an orthogonal routing.
  * If useLbls is true, issues a warning and sets useLbls=false.
  *
+ * @returns 0 on success; -1 when mkMaze fails (graphviz 16.1, 178fe6d2f). A
+ *   shortPath or assignTracks failure still returns 0, as in C (`goto
+ *   orthofinish` falls through to `return 0`).
  * @see lib/ortho/ortho.c:orthoEdges
  */
 export function orthoEdges(
   g: OrthoGraph,
   useLbls: boolean,
   clipAndInstall?: ClipAndInstallFn,
-): void {
+): number {
   if (useLbls) {
     console.warn(
       "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n",
@@ -138,6 +152,7 @@ export function orthoEdges(
   void useLbls; // suppress lint on intentional reassign
 
   const mp = mkMaze(g);
+  if (mp === null) return -1; // C frees ps (Concentrate) and es first
   const sg = mp.sg;
 
   // collect and sort edges by length. C ortho.c sorts via qsort(edgecmp), which
@@ -153,14 +168,7 @@ export function orthoEdges(
   const sn = sg.nodes[gstart];
   const dn = sg.nodes[gstart + 1];
 
-  // ensure the two dummy nodes exist
-  while (sg.nodes.length < gstart + 2) {
-    sg.nodes.push({
-      nVal: 0, nIdx: 0, nDad: null, nEdge: null,
-      nAdj: 0, saveNAdj: 0, cells: [null, null],
-      adjEdgeList: [], index: sg.nodes.length, isVert: false, x: 0, y: 0,
-    });
-  }
+  ensureDummyNodes(sg, gstart);
 
   for (let i = 0; i < nEdges; i++) {
     const e = es[i].e;
@@ -177,7 +185,7 @@ export function orthoEdges(
     if (shortPath(pq, sg, dn, sn) !== 0) {
       pqFree(pq);
       freeMaze(mp);
-      return;
+      return 0;
     }
 
     routeList[i] = convertSPtoRoute(sg, sn, dn);
@@ -190,7 +198,7 @@ export function orthoEdges(
   assignSegs(routeList, mp);
   if (assignTracks(mp) !== 0) {
     freeMaze(mp);
-    return;
+    return 0;
   }
 
   if (clipAndInstall) {
@@ -203,4 +211,5 @@ export function orthoEdges(
   }
 
   freeMaze(mp);
+  return 0;
 }

package/src/ortho/maze.ts

@@ -270,8 +270,11 @@ function nodeBb(n: OrthoNode): OrthoBox {
   return { LL: { x: cx - w2, y: cy - h2 }, UR: { x: cx + w2, y: cy + h2 } };
 }
 
-/** @see lib/ortho/maze.c:mkMaze */
-export function mkMaze(g: OrthoGraph): Maze {
+/**
+ * @returns the maze, or null when partition fails (graphviz 16.1)
+ * @see lib/ortho/maze.c:mkMaze
+ */
+export function mkMaze(g: OrthoGraph): Maze | null {
   const gcells: Cell[] = g.nodes.map((n) => ({
     flags: MZ_ISNODE, nedges: 0,
     edges: new Array(6).fill(null) as (SEdge | null)[],
@@ -292,6 +295,9 @@ export function mkMaze(g: OrthoGraph): Maze {
     UR: { x: BB.UR.x + MARGIN, y: BB.UR.y + MARGIN },
   };
   const rects = partition(gcells, BB);
+  // C (16.1, 312e49714): partition failure → freeMaze(mp); return NULL.
+  // freeMaze is a no-op here (GC), so only the NULL return remains.
+  if (rects === null) return null;
   const cells: Cell[] = rects.map((bb) => ({
     flags: 0, nedges: 0,
     edges: new Array(6).fill(null) as (SEdge | null)[],

package/src/ortho/partition.ts

@@ -258,9 +258,16 @@ class PartitionHelper {
 
 /**
  * Partition free space around cells into rectangular tiles.
+ *
+ * Returns null on failure (graphviz 16.1): an empty horizontal (057e8779d) or
+ * vertical (67bacf48e) trapezoid list — construct_trapezoids' failure signal —
+ * prints C's stderr line and returns NULL. C hands the result back through
+ * `LIST_DETACH(&rs, &ret, nrects)`, whose base pointer is NULL when no
+ * rectangle was appended, so an empty rectangle set is ALSO NULL to the caller
+ * (mkMaze's `rects == NULL` check), silently.
  * @see lib/ortho/partition.c:partition
  */
-export function partition(cells: Cell[], bb: OrthoBox): OrthoBox[] {
+export function partition(cells: Cell[], bb: OrthoBox): OrthoBox[] | null {
   const h = PartitionHelper;
   const nsegs = 4 * (cells.length + 1);
 
@@ -271,11 +278,19 @@ export function partition(cells: Cell[], bb: OrthoBox): OrthoBox[] {
   const hSeg = h.genSegments(cells, bb, false);
   const hPerm = h.generateRandomOrdering(nsegs);
   const hTr = constructTrapezoids(nsegs, hSeg, hPerm);
+  if (hTr.length === 0) {
+    console.error("horizontal trapezoid construction failed");
+    return null;
+  }
   const hDecomp = h.monotonateTrapezoids(hTr, hSeg, false);
 
   const vSeg = h.genSegments(cells, bb, true);
   const vPerm = h.generateRandomOrdering(nsegs);
   const vTr = constructTrapezoids(nsegs, vSeg, vPerm);
+  if (vTr.length === 0) {
+    console.error("vertical trapezoid construction failed");
+    return null;
+  }
   const vDecomp = h.monotonateTrapezoids(vTr, vSeg, true);
 
   const result: OrthoBox[] = [];
@@ -285,7 +300,7 @@ export function partition(cells: Cell[], bb: OrthoBox): OrthoBox[] {
       if (isect) result.push(isect);
     }
   }
-  return result;
+  return result.length === 0 ? null : result;
 }
 
 /**