@knowvah/dot-engine 2.3.1 → 2.4.0

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;
 }
 
 /**

package/src/ortho/trap-segment.ts

@@ -198,6 +198,7 @@ export function swapSegEndpoints(s: SegmentT): void {
 
 /**
  * Insert one segment into the trapezoidation.
+ * @returns 0 on success, -1 when threading met an invalid trapezoid (16.1)
  * @see lib/ortho/trapezoid.c:add_segment
  */
 export function addSegment(
@@ -205,7 +206,7 @@ export function addSegment(
   seg: SegmentT[],
   tr: TrapT[],
   qs: QNode[],
-): void {
+): number {
   const s = { ...seg[segnum] };
   let isSwapped = false;
   if (greaterThanOrEq(s.v1, s.v0) && !equalTo(s.v1, s.v0)) {
@@ -214,31 +215,49 @@ export function addSegment(
     isSwapped = true;
   }
 
-  let tfirst: number;
-  if (!inserted(segnum, seg, isSwapped ? LASTPT : FIRSTPT)) {
-    tfirst = insertV0(s, seg, tr, qs, segnum);
-  } else {
-    tfirst = locateEndpoint(s.v0, s.v1, s.root0, seg, qs);
-  }
+  const ctx: ThreadCtx = { s, seg, tr, qs, segnum, tribot: false, isSwapped };
+  const tfirst = firstTrap(ctx);
+  const tlast = lastTrap(ctx);
+  if (threadSegment(ctx, tfirst, tlast) !== 0) return -1;
+  seg[segnum].isInserted = true;
+  return 0;
+}
 
-  let tlast: number;
-  let tribot = false;
-  if (!inserted(segnum, seg, isSwapped ? FIRSTPT : LASTPT)) {
-    tlast = insertV1(s, seg, tr, qs, segnum);
-  } else {
-    tlast = locateEndpoint(s.v1, s.v0, s.root1, seg, qs);
-    tribot = true;
+/** add_segment locals the threading loop reads (one C stack frame). */
+interface ThreadCtx {
+  s: SegmentT; seg: SegmentT[]; tr: TrapT[]; qs: QNode[];
+  segnum: number; tribot: boolean; isSwapped: boolean;
+}
+
+/** add_segment: insert v0 in the tree, or locate it if already present. */
+function firstTrap(c: ThreadCtx): number {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? LASTPT : FIRSTPT)) {
+    return insertV0(c.s, c.seg, c.tr, c.qs, c.segnum);
   }
+  return locateEndpoint(c.s.v0, c.s.v1, c.s.root0, c.seg, c.qs);
+}
 
-  threadSegment(s, seg, tr, qs, segnum, tfirst, tlast, tribot, isSwapped);
-  seg[segnum].isInserted = true;
+/**
+ * add_segment: insert v1 in the tree, or (v1 already present) get the
+ * lowermost intersecting trapezoid and mark the bottom as a triangle.
+ */
+function lastTrap(c: ThreadCtx): number {
+  if (!inserted(c.segnum, c.seg, c.isSwapped ? FIRSTPT : LASTPT)) {
+    return insertV1(c.s, c.seg, c.tr, c.qs, c.segnum);
+  }
+  c.tribot = true;
+  return locateEndpoint(c.s.v1, c.s.v0, c.s.root1, c.seg, c.qs);
 }
 
-function threadSegment(
-  s: SegmentT, seg: SegmentT[], tr: TrapT[], qs: QNode[],
-  segnum: number, tfirst: number, tlast: number,
-  tribot: boolean, isSwapped: boolean,
-): void {
+/**
+ * Split every trapezoid s crosses, top to bottom, then merge both sides.
+ * Returns -1 (after C's stderr line) when a crossed trapezoid has no valid
+ * lower neighbour — graphviz 16.1 (3c01aaeb4) returns from add_segment there;
+ * 15.x printed "add_segment: error" and broke out of the loop.
+ * @see lib/ortho/trapezoid.c:add_segment (threading loop)
+ */
+function threadSegment(c: ThreadCtx, tfirst: number, tlast: number): number {
+  const { s, seg, tr, qs, segnum, tribot, isSwapped } = c;
   let tfirstr = INVALID_TRAP;
   let tlastr = INVALID_TRAP;
   let t = tfirst;
@@ -258,12 +277,17 @@ function threadSegment(
     if (equalTo(tr[t].lo, tr[tlast].lo)) tlastr = tn;
 
     const tSav = t; const tnSav = tn;
+    if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) { // error
+      console.error("trapezoid segment construction failed");
+      return -1;
+    }
     t = advanceT(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
     tr[tSav].rseg = segnum; tr[tnSav].lseg = segnum;
   }
 
   mergeTrapezoids(segnum, tfirst, tlast, S_LEFT, tr, qs);
   mergeTrapezoids(segnum, tfirstr, tlastr, S_RIGHT, tr, qs);
+  return 0;
 }
 
 function advanceT(
@@ -271,9 +295,8 @@ function advanceT(
   t: number, tn: number, tlast: number,
   segnum: number, isSwapped: boolean, tribot: boolean,
 ): number {
-  if (!isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
-    return INVALID_TRAP; // error
-  } else if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
+  // The "neither below is valid" error case returns from threadSegment first.
+  if (isValidTrap(tr[t].d0) && !isValidTrap(tr[t].d1)) {
     handleD0Only(s, seg, tr, t, tn, tlast, segnum, isSwapped, tribot);
     return tr[t].d0;
   } else if (!isValidTrap(tr[t].d0) && isValidTrap(tr[t].d1)) {

package/src/ortho/trapezoid.ts

@@ -31,29 +31,20 @@ export function constructTrapezoids(
   permute: number[],
 ): TrapT[] {
   const qs: QNode[] = [];
-  const tr: TrapT[] = [];
-  // index 0 is a sentinel (invalid trap)
-  tr.push({
-    lseg: 0, rseg: 0,
-    hi: { x: 0, y: 0 }, lo: { x: 0, y: 0 },
-    u0: 0, u1: 0, d0: 0, d1: 0,
-    sink: 0, usave: 0, uside: 0, isValid: false,
-  });
+  const tr: TrapT[] = [sentinelTrap()];
 
   let segi = 0;
   const root = initQueryStructure(permute[segi++], seg, tr, qs);
+  seedRoots(nseg, seg, root);
 
-  for (let i = 1; i <= nseg; i++) {
-    seg[i].root0 = root;
-    seg[i].root1 = root;
-  }
-
+  // C (16.1, 3660b260e): an add_segment failure LIST_FREEs the trapezoid list
+  // and jumps to `done`, so the caller receives an EMPTY list.
   const logstar = mathLogstarN(nseg);
   for (let h = 1; h <= logstar; h++) {
     const lo = mathN(nseg, h - 1) + 1;
     const hi = mathN(nseg, h);
     for (let i = lo; i <= hi; i++) {
-      addSegment(permute[segi++], seg, tr, qs);
+      if (addSegment(permute[segi++], seg, tr, qs) !== 0) return [];
     }
     for (let i = 1; i <= nseg; i++) {
       findNewRoots(i, seg, tr, qs);
@@ -62,12 +53,30 @@ export function constructTrapezoids(
 
   const remaining = mathN(nseg, logstar) + 1;
   for (let i = remaining; i <= nseg; i++) {
-    addSegment(permute[segi++], seg, tr, qs);
+    if (addSegment(permute[segi++], seg, tr, qs) !== 0) return [];
   }
 
   return tr;
 }
 
+/** Index 0 of the trapezoid list is a sentinel (invalid trap). */
+function sentinelTrap(): TrapT {
+  return {
+    lseg: 0, rseg: 0,
+    hi: { x: 0, y: 0 }, lo: { x: 0, y: 0 },
+    u0: 0, u1: 0, d0: 0, d1: 0,
+    sink: 0, usave: 0, uside: 0, isValid: false,
+  };
+}
+
+/** construct_trapezoids: every segment starts at the initial query root. */
+function seedRoots(nseg: number, seg: SegmentT[], root: number): void {
+  for (let i = 1; i <= nseg; i++) {
+    seg[i].root0 = root;
+    seg[i].root1 = root;
+  }
+}
+
 // ─── init_query_structure ─────────────────────────────────────────────────────
 
 import {