@knowvah/dot-engine 2.6.3 → 2.6.5

package/src/common/splines-geom.ts

@@ -9,6 +9,7 @@
  */
 
 import type { Point, Box } from '../model/geom.js';
+import { bezier as evalBezier } from './bezier.js';
 
 // ---------------------------------------------------------------------------
 // Approximate equality
@@ -29,33 +30,12 @@ export function approxEqPt(p: Point, q: Point, tol: number): boolean {
 // ---------------------------------------------------------------------------
 
 /**
- * Evaluates cubic Bezier sp[] at parameter t.
- * When left !== null, fills left[0..3] with the left subdivision.
- * When right !== null, fills right[0..3] with the right subdivision.
- * Returns the point on the curve.
+ * Evaluates cubic Bezier sp[] at parameter t (left/right fill as in C): the
+ * shared fused bezier(), re-exported under the name this module's callers use.
  *
- * @see lib/common/geomprocs.h:Bezier
+ * @see lib/common/utils.c:Bezier
  */
-export function evalBezier(
-  sp: Point[],
-  t: number,
-  left: Point[] | null,
-  right: Point[] | null,
-): Point {
-  const ab: Point = { x: sp[0].x + t * (sp[1].x - sp[0].x), y: sp[0].y + t * (sp[1].y - sp[0].y) };
-  const bc: Point = { x: sp[1].x + t * (sp[2].x - sp[1].x), y: sp[1].y + t * (sp[2].y - sp[1].y) };
-  const cd: Point = { x: sp[2].x + t * (sp[3].x - sp[2].x), y: sp[2].y + t * (sp[3].y - sp[2].y) };
-  const abbc: Point = { x: ab.x + t * (bc.x - ab.x), y: ab.y + t * (bc.y - ab.y) };
-  const bccd: Point = { x: bc.x + t * (cd.x - bc.x), y: bc.y + t * (cd.y - bc.y) };
-  const pt: Point = { x: abbc.x + t * (bccd.x - abbc.x), y: abbc.y + t * (bccd.y - abbc.y) };
-  if (left !== null) {
-    left[0] = sp[0]; left[1] = ab; left[2] = abbc; left[3] = pt;
-  }
-  if (right !== null) {
-    right[0] = pt; right[1] = bccd; right[2] = cd; right[3] = sp[3];
-  }
-  return pt;
-}
+export { evalBezier };
 
 // ---------------------------------------------------------------------------
 // Bounding box update

package/src/common/splines-routespl.ts

@@ -14,6 +14,7 @@ import type { Path } from './types.js';
 import { shortestPath, routeSpline, makePolyline } from '../pathplan/index.js';
 import type { Poly } from '../pathplan/types.js';
 import { INIT_DELTA, LOOP_TRIES, ROUTESPL_FUDGE } from './splines-constants.js';
+import { fma } from './fma.js';
 
 // ---------------------------------------------------------------------------
 // Stage-dump hook (diagnosis only; null in production — same pattern as
@@ -193,21 +194,28 @@ export function checkPath(boxn: number, boxes: Box[], pp: Path): boolean {
 // limitBoxes helpers
 // ---------------------------------------------------------------------------
 
-/** Evaluate de Casteljau subdivision to get a point on a cubic Bezier. */
+/** C's inlined de Casteljau: `sp[k].x += t * (sp[k+1].x - sp[k].x)`, which clang
+ * contracts to fma(t, b - a, a) (oracle `_limitBoxes`: fsub + fmadd, x12). Not
+ * utils.c:Bezier's form, so it does not use the shared bezier().
+ * @see lib/common/routespl.c:limitBoxes (lines 251-262)
+ */
 function deCasteljauPoint(
   p0: Point, p1: Point, p2: Point, p3: Point, t: number,
 ): Point {
-  const ax = p0.x + t * (p1.x - p0.x);
-  const ay = p0.y + t * (p1.y - p0.y);
-  const bx = p1.x + t * (p2.x - p1.x);
-  const by = p1.y + t * (p2.y - p1.y);
-  const cx = p2.x + t * (p3.x - p2.x);
-  const cy = p2.y + t * (p3.y - p2.y);
-  const dx = ax + t * (bx - ax);
-  const dy = ay + t * (by - ay);
-  const ex = bx + t * (cx - bx);
-  const ey = by + t * (cy - by);
-  return { x: dx + t * (ex - dx), y: dy + t * (ey - dy) };
+  let s0x = p0.x, s0y = p0.y, s1x = p1.x, s1y = p1.y, s2x = p2.x, s2y = p2.y;
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  s1x = fma(t, s2x - s1x, s1x);
+  s1y = fma(t, s2y - s1y, s1y);
+  s2x = fma(t, p3.x - s2x, s2x);
+  s2y = fma(t, p3.y - s2y, s2y);
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  s1x = fma(t, s2x - s1x, s1x);
+  s1y = fma(t, s2y - s1y, s1y);
+  s0x = fma(t, s1x - s0x, s0x);
+  s0y = fma(t, s1y - s0y, s0y);
+  return { x: s0x, y: s0y };
 }
 
 /** Update box x-extents for a sample point if it lies in the y-band. */
@@ -253,7 +261,7 @@ export function limitBoxes(
   pn: number,
   delta: number,
 ): void {
-  const numDiv = Math.round(delta * boxn);
+  const numDiv = delta * boxn; // C: const double num_div (routespl.c:242)
   for (let splinepi = 0; splinepi + 3 < pn; splinepi += 3) {
     sampleBezierSegment(boxes, boxn, pps, splinepi, numDiv);
   }

package/src/common/taper.ts

@@ -9,6 +9,7 @@
 // @see lib/common/taper.c:taper
 
 import type { Point, Bezier } from '../model/geom.js';
+import { bezier } from './bezier.js';
 
 /** Sample points per Bézier segment. @see taper.c:BEZIERSUBDIVISION */
 const BEZIER_SUBDIVISION = 20;
@@ -65,19 +66,6 @@ function l2dist(p0: Point, p1: Point): number {
   return Math.hypot(p0.x - p1.x, p0.y - p1.y);
 }
 
-/** Evaluate a cubic Bézier at t via de Casteljau. @see lib/common/utils.c:Bezier */
-function bezierPoint(v: readonly Point[], t: number): Point {
-  const vx = [v[0]!.x, v[1]!.x, v[2]!.x, v[3]!.x];
-  const vy = [v[0]!.y, v[1]!.y, v[2]!.y, v[3]!.y];
-  for (let i = 1; i <= 3; i++) {
-    for (let j = 0; j <= 3 - i; j++) {
-      vx[j] = (1.0 - t) * vx[j]! + t * vx[j + 1]!;
-      vy[j] = (1.0 - t) * vy[j]! + t * vy[j + 1]!;
-    }
-  }
-  return { x: vx[0]!, y: vy[0]! };
-}
-
 interface PathPoint {
   x: number;
   y: number;
@@ -107,7 +95,7 @@ function pathtolines(bez: Bezier): PathPoint[] {
     for (let j = 1; j <= 3; j++) V[j] = A[i + j]!;
     let p0 = V[0]!;
     for (let step = 1; step <= BEZIER_SUBDIVISION; step++) {
-      const p1 = bezierPoint(V, step / BEZIER_SUBDIVISION);
+      const p1 = bezier(V, step / BEZIER_SUBDIVISION, null, null);
       linelen += l2dist(p0, p1);
       push(p1, linelen);
       p0 = p1;

package/src/gvc/anchor.ts

@@ -20,6 +20,7 @@ import type { GraphObj } from '../common/subst.js';
 import { substObjAnchor, interpretCRNL } from '../common/subst.js';
 import { parseStyleFlags } from '../common/style-resolve.js';
 import { nodeAttr } from '../common/poly-init.js';
+import { bezier } from '../common/bezier.js';
 import type { RendererPlugin } from './context.js';
 import { MapShape, type ObjState, type RenderJob } from './job.js';
 
@@ -447,20 +448,10 @@ function checkControlPoints(cp: Point[]): boolean {
 /** de Casteljau split of a cubic at t=0.5, returning left & right control sets.
  * @see lib/common/utils.c:Bezier */
 function bezierHalf(v: Point[]): { left: Point[]; right: Point[] } {
-  const t = 0.5;
-  const vt: Point[][] = [v.slice(0, 4)];
-  for (let i = 1; i <= 3; i++) {
-    vt[i] = [];
-    for (let j = 0; j <= 3 - i; j++) {
-      const a = vt[i - 1]![j]!;
-      const b = vt[i - 1]![j + 1]!;
-      vt[i]![j] = { x: (1 - t) * a.x + t * b.x, y: (1 - t) * a.y + t * b.y };
-    }
-  }
-  return {
-    left: [vt[0]![0]!, vt[1]![0]!, vt[2]![0]!, vt[3]![0]!],
-    right: [vt[3]![0]!, vt[2]![1]!, vt[1]![2]!, vt[0]![3]!],
-  };
+  const left: Point[] = [];
+  const right: Point[] = [];
+  bezier(v, 0.5, left, right);
+  return { left, right };
 }
 
 /** approx_bezier: flatten a cubic to a polyline. @see lib/common/emit.c */

package/src/layout/dot/__fixtures__/2796-flat-labeled-lost.dot

@@ -0,0 +1,161 @@
+// Reduced (ddmin) from graphviz tests/2796.dot: one labeled flat edge whose
+// routesplines fails. Native 16.1.0 reports the failure once.
+digraph "troublesome" {
+  rankdir=LR
+  I -> 36
+  subgraph cluster_0 {
+  }
+  subgraph cluster_6 {
+  57
+  12
+  }
+  subgraph cluster_10 {
+  26
+  }
+  subgraph cluster_14 {
+  }
+  subgraph cluster_17 {
+  }
+  subgraph cluster_18 {
+  }
+  subgraph cluster_21 {
+  55
+  }
+  subgraph cluster_23 {
+  }
+  subgraph cluster_24 {
+  }
+  subgraph cluster_33 {
+  39
+  4
+  1
+  }
+  subgraph cluster_35 {
+  }
+  subgraph cluster_37 {
+  }
+  subgraph cluster_38 {
+  }
+  subgraph cluster_39 {
+  }
+  subgraph cluster_40 {
+  46
+  }
+  subgraph cluster_41 {
+  }
+  subgraph cluster_42 {
+  }
+  1 -> 48 [label="p1"]
+  2 -> 48 [label="!p0 & !p1"]
+  3 -> 26 [label="p0 & p2"]
+  4 -> 1 [label="p0 & p1 & p2"]
+  4 -> 48 [label="!p1"]
+  12 -> 57 [label="p0 & p1"]
+  13 -> 28 [label="p0 & p1 & p2"]
+  15 -> 16 [label="!p0 & p1 & p2"]
+  16 -> 26 [label="p0 & p2"]
+  17 -> 3 [label="!p0 & !p2"]
+  17 -> 21 [label="p0 & !p2"]
+  20 -> 48 [label="!p0 & p1"]
+  20 -> 50 [label="p0 & !p1"]
+  21 -> 3 [label="!p0 & p1 & !p2"]
+  21 -> 12 [label="p0 & p1 & p2"]
+  21 -> 48 [label="!p0 & !p1"]
+  21 -> 57 [label="p0 & !p1"]
+  22 -> 48 [label="!p0"]
+  22 -> 52 [label="p0 & p2"]
+  23 -> 14 [label="p0 & p1 & p2"]
+  23 -> 21 [label="p0 & p1 & !p2"]
+  23 -> 30 [label="p0 & !p1 & !p2"]
+  23 -> 48 [label="(!p0 & !p1) | (!p0 & p2)"]
+  23 -> 52 [label="p0 & !p1 & p2"]
+  24 -> 3 [label="!p0 & p1 & !p2"]
+  24 -> 15 [label="p0 & p1 & !p2"]
+  24 -> 52 [label="p0 & !p1 & p2"]
+  25 -> 18 [label="!p0 & p1 & !p2"]
+  25 -> 34 [label="!p0 & p1 & p2"]
+  26 -> 48 [label="p1"]
+  27 -> 48 [label="!p0 & !p2"]
+  27 -> 57 [label="p0 & !p2"]
+  28 -> 29 [label="p0 & !p1 & !p2"]
+  28 -> 48 [label="!p0 | p1"]
+  29 -> 48 [label="!p0 | !p1"]
+  30 -> 48 [label="!p0"]
+  32 -> 30 [label="p0 & !p1 & !p2"]
+  32 -> 48 [label="!p0"]
+  32 -> 52 [label="p0 & p2"]
+  32 -> 55 [label="p0 & p1 & !p2"]
+  33 -> 48 [label="!p0"]
+  33 -> 52 [label="p0 & p2"]
+  33 -> 55 [label="p0 & !p2"]
+  34 -> 0 [label="p0 & !p2"]
+  34 -> 2 [label="p0 & p2"]
+  34 -> 48 [label="!p0"]
+  35 -> 9 [label="p0 & !p1 & !p2"]
+  35 -> 14 [label="p0 & !p1 & p2"]
+  35 -> 55 [label="p0 & p1 & !p2"]
+  36 -> 5 [label="!p0 & !p1 & !p2"]
+  36 -> 6 [label="p0 & !p1 & p2"]
+  36 -> 17 [label="p0 & !p1 & !p2"]
+  36 -> 37 [label="p1 & !p2"]
+  36 -> 38 [label="p1 & p2"]
+  36 -> 44 [label="!p0 & !p1 & p2"]
+  37 -> 10 [label="!p0 & !p1 & !p2"]
+  37 -> 23 [label="p0 & !p1 & !p2"]
+  38 -> 24 [label="p0 & !p1 & !p2"]
+  38 -> 35 [label="p0 & !p1 & p2"]
+  38 -> 37 [label="!p0 & p1 & !p2"]
+  38 -> 39 [label="p0 & p1 & p2"]
+  38 -> 44 [label="!p0 & !p1 & p2"]
+  38 -> 53 [label="p0 & p1 & !p2"]
+  39 -> 5 [label="!p0 & !p1 & !p2"]
+  39 -> 24 [label="p0 & !p1 & !p2"]
+  39 -> 35 [label="p0 & !p1 & p2"]
+  39 -> 43 [label="p0 & p1 & p2"]
+  39 -> 44 [label="!p0 & !p1 & p2"]
+  39 -> 48 [label="!p0 & p1"]
+  39 -> 54 [label="p0 & p1 & !p2"]
+  40 -> 10 [label="!p0 & !p1 & !p2"]
+  41 -> 5 [label="!p0 & !p1 & !p2"]
+  42 -> 5 [label="!p0 & !p1 & !p2"]
+  42 -> 44 [label="!p0 & !p1 & p2"]
+  42 -> 48 [label="p1"]
+  42 -> 51 [label="p0 & !p1 & p2"]
+  43 -> 32 [label="p0 & !p1 & !p2"]
+  43 -> 33 [label="p0 & !p1 & p2"]
+  43 -> 48 [label="!p0"]
+  43 -> 54 [label="p0 & p1 & !p2"]
+  44 -> 19 [label="p0 & p2"]
+  44 -> 20 [label="p0 & !p2"]
+  44 -> 48 [label="!p0"]
+  45 -> 28 [label="p0 & p2"]
+  45 -> 29 [label="p0 & !p2"]
+  45 -> 48 [label="!p0"]
+  46 -> 3 [label="!p0 & p1 & !p2"]
+  46 -> 48 [label="!p1 | (!p0 & p2)"]
+  46 -> 51 [label="p0 & p1 & p2"]
+  46 -> 56 [label="p0 & p1 & !p2"]
+  47 -> 3 [label="!p0 & p1 & !p2"]
+  47 -> 48 [label="!p1"]
+  47 -> 51 [label="p0 & p1 & p2"]
+  47 -> 56 [label="p0 & p1 & !p2"]
+  49 -> 40 [label="!p0 & p1 & !p2"]
+  49 -> 41 [label="!p0 & p1 & p2"]
+  49 -> 42 [label="p0 & p1 & p2"]
+  49 -> 48 [label="!p1"]
+  51 -> 4 [label="p0 & !p1 & !p2"]
+  51 -> 48 [label="p1 | (!p0 & p2)"]
+  52 -> 48 [label="!p0"]
+  52 -> 57 [label="p0 & p1"]
+  53 -> 22 [label="p0 & !p1 & !p2"]
+  53 -> 33 [label="p0 & !p1 & p2"]
+  53 -> 39 [label="p0 & p1 & p2"]
+  53 -> 40 [label="!p0 & p1 & !p2"]
+  53 -> 41 [label="!p0 & p1 & p2"]
+  53 -> 48 [label="!p0 & !p1"]
+  54 -> 22 [label="p0 & !p1 & !p2"]
+  54 -> 48 [label="!p0"]
+  55 -> 48 [label="!p0"]
+  55 -> 57 [label="p0 & !p1"]
+  56 -> 3 [label="!p0 & p1 & !p2"]
+}

package/src/layout/dot/compound-clip.ts

@@ -9,6 +9,7 @@
 
 import type { Point, Box } from '../../model/geom.js';
 import { cround } from '../../common/arith.js';
+import { bezier } from '../../common/bezier.js';
 
 /** Sign comparison matching C fcmp(). @see lib/util/gv_math.h:fcmp */
 export function fcmp(a: number, b: number): number {
@@ -31,26 +32,15 @@ export function midPointf(a: Point, b: Point): Point {
 // De Casteljau subdivision
 // ---------------------------------------------------------------------------
 
-type CasteljauRow = [Point, Point, Point, Point];
-
-/** One De Casteljau subdivision step. */
-export function casteljauStep(prev: CasteljauRow, t: number): CasteljauRow {
-  const u = 1 - t;
-  return [
-    { x: u * prev[0].x + t * prev[1].x, y: u * prev[0].y + t * prev[1].y },
-    { x: u * prev[1].x + t * prev[2].x, y: u * prev[1].y + t * prev[2].y },
-    { x: u * prev[2].x + t * prev[3].x, y: u * prev[2].y + t * prev[3].y },
-    { x: 0, y: 0 },
-  ];
-}
-
-/** Subdivide cubic Bezier at t; return left or right half. @see lib/common/utils.c:Bezier */
+/**
+ * Subdivide cubic Bezier at t; return left or right half, through the shared
+ * fused bezier().
+ * @see lib/common/utils.c:Bezier
+ */
 export function subdivideBezier(v: readonly Point[], t: number, side: 'left' | 'right'): Point[] {
-  const r0: CasteljauRow = [{ ...v[0] }, { ...v[1] }, { ...v[2] }, { ...v[3] }];
-  const r1 = casteljauStep(r0, t);
-  const r2 = casteljauStep(r1, t);
-  const r3 = casteljauStep(r2, t);
-  return side === 'left' ? [r0[0], r1[0], r2[0], r3[0]] : [r3[0], r2[1], r1[2], r0[3]];
+  const half: Point[] = [];
+  bezier([...v], t, side === 'left' ? half : null, side === 'right' ? half : null);
+  return half;
 }
 
 // ---------------------------------------------------------------------------

package/src/layout/dot/compound-geom.ts

@@ -10,6 +10,7 @@
 
 import type { Point, Box } from '../../model/geom.js';
 import { cround } from '../../common/arith.js';
+import { bezier } from '../../common/bezier.js';
 
 // ---------------------------------------------------------------------------
 // Primitive helpers
@@ -49,24 +50,10 @@ export function midPointf(a: Point, b: Point): Point {
 // Bezier subdivision
 // ---------------------------------------------------------------------------
 
-/** One triangle row for De Casteljau; avoids nested array allocation. */
-type CasteljauRow = [Point, Point, Point, Point];
-
-/** Compute one row of the De Casteljau triangle at parameter t. */
-export function casteljauStep(prev: CasteljauRow, t: number): CasteljauRow {
-  const u = 1 - t;
-  return [
-    { x: u * prev[0].x + t * prev[1].x, y: u * prev[0].y + t * prev[1].y },
-    { x: u * prev[1].x + t * prev[2].x, y: u * prev[1].y + t * prev[2].y },
-    { x: u * prev[2].x + t * prev[3].x, y: u * prev[2].y + t * prev[3].y },
-    { x: 0, y: 0 }, // unused slot; keeps tuple type uniform
-  ];
-}
-
 /**
  * De Casteljau subdivision of a cubic Bezier at parameter t.
- * Returns left-half or right-half control points.
- * Matches C Bezier() triangle computation.
+ * Returns left-half or right-half control points through the shared fused
+ * bezier().
  *
  * @see lib/common/utils.c:Bezier
  */
@@ -75,13 +62,9 @@ export function subdivideBezier(
   t: number,
   side: 'left' | 'right',
 ): Point[] {
-  const r0: CasteljauRow = [{ ...v[0] }, { ...v[1] }, { ...v[2] }, { ...v[3] }];
-  const r1 = casteljauStep(r0, t);
-  const r2 = casteljauStep(r1, t);
-  const r3 = casteljauStep(r2, t);
-  return side === 'left'
-    ? [r0[0], r1[0], r2[0], r3[0]]
-    : [r3[0], r2[1], r1[2], r0[3]];
+  const half: Point[] = [];
+  bezier([...v], t, side === 'left' ? half : null, side === 'right' ? half : null);
+  return half;
 }
 
 // ---------------------------------------------------------------------------

package/src/layout/dot/compound.ts

@@ -19,7 +19,7 @@ import { dist } from '../../common/arrows-geometry.js';
 
 // Re-export geometry helpers so existing callers (tests) import from one place.
 export {
-  fcmp, inBoxf, midPointf, casteljauStep, subdivideBezier,
+  fcmp, inBoxf, midPointf, subdivideBezier,
   countVertCross, countHorzCross, tryUpdateIntersect,
   splineIntersectf,
   tryLeftSide, tryRightSide, tryBottomSide, tryTopSide, boxIntersectf,

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

@@ -11,49 +11,26 @@
 import type { Point } from '../../model/geom.js';
 import { parseArrow, resolveArrowType } from '../../common/arrows.js';
 import { arrowLength } from '../../common/arrows-shapes.js';
+import { bezier } from '../../common/bezier.js';
 
 // ---------------------------------------------------------------------------
 // De Casteljau subdivision
 // @see lib/common/utils.c:Bezier
 // ---------------------------------------------------------------------------
 
-/**
- * Build the De Casteljau triangle for a cubic Bezier at parameter t.
- * v[i][j] = (1-t)*v[i-1][j] + t*v[i-1][j+1].
- * @see lib/common/utils.c:Bezier (triangle computation section)
- */
-function deCasteljauTriangle(sp: Point[], t: number): Point[][] {
-  const u = 1 - t;
-  const v: Point[][] = [
-    [sp[0], sp[1], sp[2], sp[3]],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }],
-    [{ x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }],
-  ];
-  for (let i = 1; i <= 3; i++) {
-    for (let j = 0; j <= 3 - i; j++) {
-      v[i][j] = {
-        x: u * v[i - 1][j].x + t * v[i - 1][j + 1].x,
-        y: u * v[i - 1][j].y + t * v[i - 1][j + 1].y,
-      };
-    }
-  }
-  return v;
-}
-
 /**
  * De Casteljau subdivision of a cubic Bezier at parameter t.
- * Returns [left4, right4, midpoint].
+ * Returns [left4, right4, midpoint], computed by the shared fused bezier().
  * @see lib/common/utils.c:Bezier
  */
 export function bezierSubdivide(
   sp: Point[],
   t: number,
 ): [Point[], Point[], Point] {
-  const v = deCasteljauTriangle(sp, t);
-  const left: Point[] = [v[0][0], v[1][0], v[2][0], v[3][0]];
-  const right: Point[] = [v[3][0], v[2][1], v[1][2], v[0][3]];
-  return [left, right, v[3][0]];
+  const left: Point[] = [];
+  const right: Point[] = [];
+  const mid = bezier(sp, t, left, right);
+  return [left, right, mid];
 }
 
 // ---------------------------------------------------------------------------

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

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: EPL-2.0
 /**
  * Dot-local adapter between the dot `Graph` model and the `orthoEdges`
- * pipeline (`src/ortho`). Mirrors neato's private `OrthoHelper`
- * (`neato/splines.ts:247`) rather than extracting a shared helper, so the
- * working neato path is untouched (ADR-1) — this matches C, where dotgen and
- * neatogen each have their own call site into `ortho.c:orthoEdges`.
+ * pipeline (`src/ortho`). Mirrors neato's `OrthoHelper` (`neato/splines.ts`);
+ * the two share only the concentrate dedup (`isConcentrateDup`), as C has one
+ * gather loop while dotgen and neatogen each have their own call site into
+ * `ortho.c:orthoEdges`.
  *
  * @see lib/dotgen/dotsplines.c:dot_splines_ (EDGETYPE_ORTHO branch)
  * @see src/layout/neato/splines.ts:OrthoHelper
@@ -56,7 +56,7 @@ function buildNodes(nodeArr: Node[]): OrthoNodeArr {
  * (min, max) and makes one isInPS/addPS pair on it.
  * @see lib/ortho/ortho.c:1221-1229 (orthoEdges Concentrate PS)
  */
-function isConcentrateDup(ps: PointSet, e: Edge): boolean {
+export function isConcentrateDup(ps: PointSet, e: Edge): boolean {
   const ti = e.tail.id;
   const hi = e.head.id;
   const lo = ti <= hi ? ti : hi;

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

@@ -149,7 +149,9 @@ export function makeFlatLabeledEdge(g: Graph, e: Edge): boolean {
   // Degenerate route (routesplines pn=0): label set, no spline installed — C's
   // make_flat_labeled_edge returns the same way; emit's edge_in_box then decides
   // whether the (untranslated) label overlaps the clip. Still HANDLED → true.
-  if (ps === null || ps.length === 0) return true;
+  // C's dot_splines_ visits the edge once, so mark it lost: the routeDotEdges
+  // backstop must not route (and report the failure) a second time.
+  if (ps === null || ps.length === 0) { e.info.lost = true; return true; }
   if (!tailIsLeft) ps.reverse();
   clipAndInstall(e, e.head, ps, ps.length, { ...buildDotSinfo(), ignoreSwap: true });
   return true;

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

@@ -17,6 +17,7 @@ import { IGNORED } from './rank.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import { nodesInSeq } from './decomp.js';
 import { RADIANS } from '../../common/arith.js';
+import { bezier } from '../../common/bezier.js';
 
 // ---------------------------------------------------------------------------
 // TextLabel interface (minimal — full type deferred to Batch 5b)
@@ -125,33 +126,6 @@ export const PORT_LABEL_DISTANCE = 10;
 /** Default port-label angle in degrees (CW negative). @see lib/common/const.h:PORT_LABEL_ANGLE */
 export const PORT_LABEL_ANGLE = -25;
 
-// ---------------------------------------------------------------------------
-// cubicBezierAt — de Casteljau at parameter t (Bezier() in utils.c)
-// @see lib/common/utils.c:175-203
-// ---------------------------------------------------------------------------
-
-/**
- * Evaluate a cubic Bezier curve at parameter t using the de Casteljau
- * triangle computation.  Requires pts[0..3].  No Left/Right subdivision
- * output needed here, so they are omitted.
- *
- * @see lib/common/utils.c:Bezier
- */
-function cubicBezierAt(pts: readonly { x: number; y: number }[], t: number): { x: number; y: number } {
-  // Triangle computation (degree = 3)
-  const p0 = pts[0], p1 = pts[1], p2 = pts[2], p3 = pts[3];
-  const mt = 1.0 - t;
-  // Level 1
-  const q0 = { x: mt * p0.x + t * p1.x, y: mt * p0.y + t * p1.y };
-  const q1 = { x: mt * p1.x + t * p2.x, y: mt * p1.y + t * p2.y };
-  const q2 = { x: mt * p2.x + t * p3.x, y: mt * p2.y + t * p3.y };
-  // Level 2
-  const r0 = { x: mt * q0.x + t * q1.x, y: mt * q0.y + t * q1.y };
-  const r1 = { x: mt * q1.x + t * q2.x, y: mt * q1.y + t * q2.y };
-  // Level 3
-  return { x: mt * r0.x + t * r1.x, y: mt * r0.y + t * r1.y };
-}
-
 // ---------------------------------------------------------------------------
 // Bezier endpoint extraction helpers
 // @see lib/common/splines.c:place_portlabel:1331-1351
@@ -171,7 +145,7 @@ function tailEndpoints(bez: BezierSeg): { pe: { x: number; y: number }; pf: { x:
     return { pe: bez.sp, pf: bez.list[0] };
   }
   const pe = bez.list[0];
-  const pf = cubicBezierAt(bez.list, 0.1);
+  const pf = bezier(bez.list, 0.1, null, null);
   return { pe, pf };
 }
 
@@ -192,7 +166,7 @@ function headEndpoints(bez: BezierSeg): { pe: { x: number; y: number }; pf: { x:
   }
   const pe = bez.list[bez.size - 1];
   const last4 = bez.list.slice(bez.size - 4, bez.size);
-  const pf = cubicBezierAt(last4, 0.9);
+  const pf = bezier(last4, 0.9, null, null);
   return { pe, pf };
 }
 

package/src/layout/neato/bfs.ts

@@ -33,7 +33,13 @@ export function bfsFixDisconnected(
   }
 }
 
-/** Process one BFS vertex: enqueue unvisited neighbours. @internal */
+/**
+ * Process one BFS vertex: enqueue unvisited neighbours. The bump is 1 when
+ * graph[0] has no ewgts (C NULL, the port's empty array), else the float
+ * ewgts truncated to DistType (int).
+ * @see lib/neatogen/bfs.c:bfs (bfs.c:41-43)
+ * @internal
+ */
 export function bfsVisitNeighbors(
   vertex: number,
   graph: VtxData[],
@@ -42,10 +48,12 @@ export function bfsVisitNeighbors(
 ): number {
   const vd = graph[vertex];
   const d = dist[vertex];
+  const unit = graph[0].ewgts.length === 0;
   for (let i = 1; i < vd.nedges; i++) {
     const nb = vd.edges[i];
     if (dist[nb] < 0) {
-      dist[nb] = d + 1;
+      // C ewgts is float*: round to float32, then (DistType) truncates
+      dist[nb] = d + (unit ? 1 : Math.trunc(Math.fround(vd.ewgts[i])));
       queue.push(nb);
     }
   }
@@ -57,8 +65,9 @@ export function bfsVisitNeighbors(
 // ---------------------------------------------------------------------------
 
 /**
- * Single-source BFS (unweighted) from `src`.
- * Populates `dist` with hop-distances; unreachable nodes get `BFS_UNREACHABLE`.
+ * Single-source BFS from `src`: first visit wins, each hop bumps by 1 or by
+ * the int-truncated ewgts (see bfsVisitNeighbors). Unreached nodes get
+ * `closestDist + 10`.
  *
  * @see lib/neatogen/bfs.c:bfs
  */