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

package/src/layout/neato/init.ts

@@ -321,21 +321,20 @@ export function mapModelToStress(model: number): number {
 // solveModel helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Run stress majorization on the graph and write results back to node positions.
- *
- * @see lib/neatogen/neatoinit.c:majorization
- */
+/** Run stress majorization and write positions back. @see lib/neatogen/neatoinit.c:majorization */
 export function runMajorization(g: Graph, mode: number, model: number): void {
   void model; // only MODEL_SHORTPATH distances are exercised by the suite
   const nodeList = assignNodeIds(g);
   const n = nodeList.length;
   const haveLen = graphHasLen(g);
-  const vtx = makeGraphDataC(g, nodeList, haveLen);
+  const vtx = makeGraphDataC(g, nodeList, haveLen, mode === MODE_HIER || mode === MODE_IPSEP);
   checkStart(g); // C: srand48(seed) immediately before initLayout draws
   const maxi = lateDouble(g.attrs.get('maxiter'), DFLT_ITERATIONS, 0);
   const epsilon = lateDouble(g.attrs.get('epsilon'), 1e-4, 0); // DFLT_TOLERANCE
-  const Dij = haveLen ? computeWeightedApspPacked(vtx, n) : computeApspPacked(vtx, n);
+  // C ipsep (stress_majorization_cola, constrained_majorization_ipsep.c:150) always uses
+  // compute_apsp_packed; kD_mkernel uses the weighted APSP iff graph->ewgts (stress.c:855).
+  const weighted = haveLen && mode !== MODE_IPSEP;
+  const Dij = weighted ? computeWeightedApspPacked(vtx, n) : computeApspPacked(vtx, n);
   const dCoords = [new Float64Array(n), new Float64Array(n)];
   stressMajorizationKDMkernel(Dij, n, dCoords, nodeList, {
     dim: DFLT_DIM, opts: OPT_EXP_FLAG, maxi, epsilon,
@@ -354,17 +353,18 @@ export function graphHasLen(g: Graph): boolean {
 }
 
 /**
- * Build the vtx_data adjacency in C's makeGraphData shape: per node,
- * out-edges then in-edges (agfstedge order), self entry at index 0,
- * duplicate neighbours merged (len keeps the max). ewgts are edge
- * lens (default 1.0) when any len attr exists, else absent so the
- * APSP uses BFS hop counts.
+ * C makeGraphData's vtx_data: per node out-edges then in-edges (agfstedge order), self at
+ * index 0, duplicate neighbours merged (len keeps the max). ewgts: lens (default 1.0) if any
+ * len attr, else 1.0 under haveDir (hier/ipsep), else absent (C NULL). eweights (haveWt)
+ * and edists are not built: nothing on a supported path reads them.
  * @see lib/neatogen/neatoinit.c:makeGraphData
  * @see lib/neatogen/stuff.c:setEdgeLen
  */
-export function makeGraphDataC(g: Graph, nodeList: Node[], haveLen: boolean): VtxData[] {
+export function makeGraphDataC(
+  g: Graph, nodeList: Node[], haveLen: boolean, haveDir: boolean,
+): VtxData[] {
   const vtx: VtxData[] = nodeList.map((_, i) => ({
-    nedges: 1, edges: [i], ewgts: haveLen ? [0] : [],
+    nedges: 1, edges: [i], ewgts: haveLen || haveDir ? [0] : [],
   }));
   for (const np of nodeList) {
     const i = np.info.id!;
@@ -382,7 +382,7 @@ export function makeGraphDataC(g: Graph, nodeList: Node[], haveLen: boolean): Vt
       }
       seen.set(vid, entry.nedges);
       entry.edges.push(vid);
-      if (haveLen) entry.ewgts.push(dist);
+      if (haveLen || haveDir) entry.ewgts.push(dist); // C neatoinit.c:827: haveDir 1.0
       entry.nedges++;
     }
   }

package/src/layout/neato/splines.ts

@@ -32,6 +32,8 @@ import {
 import { makeSelfEdge } from '../../common/splines.js';
 import { newSpline, clipAndInstall } from '../../common/splines-clip.js';
 import { orthoEdges } from '../../ortho/index.js';
+import { PointSet } from '../../common/pointset.js';
+import { isConcentrateDup } from '../dot/ortho-adapter.js';
 import type { OrthoGraph, OrthoEdge, OrthoPoint } from '../../ortho/index.js';
 import {
   EDGETYPE_NONE, EDGETYPE_LINE, EDGETYPE_ORTHO,
@@ -595,17 +597,11 @@ class OrthoHelper {
     // pair is routed (ortho.c:1223-1233). Self-loops are NOT filtered — the
     // maze routes them via addLoop.
     const concentrate = g.root.info.concentrate ?? false;
-    const seen = new Set<string>();
+    const ps = concentrate ? new PointSet() : null;
     const edges: TaggedOrthoEdge[] = [];
     for (const n of nodesInSeq(g)) {
       for (const e of n.outEdges(g)) {
-        if (concentrate) {
-          const ti = e.tail.id;
-          const hi = e.head.id;
-          const key = ti <= hi ? `${ti}|${hi}` : `${hi}|${ti}`;
-          if (seen.has(key)) continue;
-          seen.add(key);
-        }
+        if (ps && isConcentrateDup(ps, e)) continue;
         // C attachOrthoEdges endpoints: p1 = ND_coord(tail) + ED_tail_port.p,
         // q1 = ND_coord(head) + ED_head_port.p (ortho.c:1075-1076). Plumb the
         // port offset so compass/record ports (tailport=s, headport=n, …) exit

package/src/parser/index.ts

@@ -14,6 +14,7 @@ import type { Edge } from '../model/edge.js';
 import { isHtmlValue, htmlValueContent } from '../common/html-string.js';
 import { buildFromAst } from './builder.js';
 import { scanNumberAmbiguities, numberAmbiguityMessage } from './number-scan.js';
+import { syntaxErrorMessage } from './scan-token.js';
 import type { ParsedGraph } from './ast.js';
 import type { GvErrorCode, GvExpectation } from '../errors.js';
 import { DotEngineError, friendlyMessageFor, invalidArgType } from '../errors.js';
@@ -249,6 +250,7 @@ export function parse(src: string): Graph {
     if (isPeggyError(err)) {
       const start = err.location.start;
       warnNumberAmbiguities(src, start.offset);
+      console.error(syntaxErrorMessage(src, start.offset));
       const code: GvErrorCode =
         err.found === null ? 'SYNTAX_UNEXPECTED_EOF' : 'SYNTAX_ERROR';
       throw new ParseError(
@@ -270,8 +272,18 @@ export function parse(src: string): Graph {
     }
     throw err;
   }
+  try {
+    validateEdgeOperators(src, ast.directed);
+  } catch (err: unknown) {
+    // C's lexer hands the wrong operator to bison as '-': a syntax error there.
+    const offset = err instanceof ParseError ? err.location.offset : undefined;
+    if (offset !== undefined) {
+      warnNumberAmbiguities(src, offset);
+      console.error(syntaxErrorMessage(src, offset));
+    }
+    throw err;
+  }
   warnNumberAmbiguities(src, src.length);
-  validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }