@knowvah/dot-engine 2.3.0 → 2.4.0

package/src/parser/dot.pegjs

@@ -57,24 +57,36 @@ Stmt
 // grammar.y: attrtype : T_graph | T_node | T_edge
 // grammar.y: graphattrdefs : attrassignment  (bare key=value at graph level)
 AttrStmt
-  = t:AttrType _ attrs:AttrList
-    { return { type: "attr", target: t, attrs: attrs }; }
+  = t:AttrType _ m:OptMacroName attrs:AttrListReq
+    {
+      // grammar.y:attrstmt calls nomacros() when a macro name is present;
+      // the attributes are still applied unchanged.
+      if (m) console.error("Warning: attribute macros not implemented");
+      return { type: "attr", target: t, attrs: attrs };
+    }
   / a:AttrAssignment
     { return { type: "assign", key: a.key, value: a.value }; }
 
+// grammar.y: optmacroname : atom '=' | /* empty */
+// @see grammar.y:nomacros -- agwarningf("attribute macros not implemented")
+OptMacroName
+  = Atom _ "=" _ { return true; }
+  / "" { return false; }
+
 // grammar.y: attrtype : T_graph | T_node | T_edge
 AttrType
   = GraphKw  { return "graph"; }
   / NodeKw   { return "node"; }
   / EdgeKw   { return "edge"; }
 
-// grammar.y: optattr : attrlist | /* empty */
-// grammar.y: attrlist : optattr '[' optattrdefs ']'
-AttrList
+// grammar.y: attrlist : optattr '[' optattrdefs ']'   (one or more bracket groups)
+AttrListReq
   = _ "[" _ defs:AttrDefs _ "]" rest:AttrList
     { return defs.concat(rest); }
-  / _ "[" _ defs:AttrDefs _ "]"
-    { return defs; }
+
+// grammar.y: optattr : attrlist | /* empty */
+AttrList
+  = AttrListReq
   / "" { return []; }
 
 // grammar.y: optattrdefs : optattrdefs attrdefs | /* empty */
@@ -215,10 +227,13 @@ Name
   = first:[A-Za-z_\x80-￿] rest:[A-Za-z_0-9\x80-￿]*
     { return first + rest.join(""); }
 
-// scan.l: NUMBER = [-]?(({DIGIT}+(\.{DIGIT}*)?)|(\.{DIGIT}+))
-// Returned as string per spec requirement.
+// scan.l: NUMBER = [-]?(({DIGIT}+(\.{DIGIT}*)?)|(\.{DIGIT}+))(\.|{LETTER})?
+// There is no exponent: `1e5` lexes as NUMBER `1e`, which chkNum splits into
+// `1` and the NAME `e5`. The optional trailing '.'/LETTER is always split off
+// by chkNum (yyless), so it is never part of the atom; its warning is emitted
+// by number-scan.ts. Returned as string per spec requirement.
 NumericLiteral
-  = s:( "-"? ( [0-9]+ ( "." [0-9]* )? / "." [0-9]+ ) ( [eE] [+-]? [0-9]+ )? )
+  = s:( "-"? ( [0-9]+ ( "." [0-9]* )? / "." [0-9]+ ) )
     { return Array.isArray(s) ? s.flat(Infinity).filter(x => x !== null && x !== undefined).join("") : String(s); }
 
 // ── Case-insensitive keywords ─────────────────────────────────────────────────

package/src/parser/index.ts

@@ -13,6 +13,7 @@ import type { GraphKind } from '../model/graph.js';
 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 type { ParsedGraph } from './ast.js';
 import type { GvErrorCode, GvExpectation } from '../errors.js';
 import { DotEngineError, friendlyMessageFor, invalidArgType } from '../errors.js';
@@ -223,6 +224,18 @@ export function isPeggyError(err: unknown): err is {
  *   is too deep
  * @throws TypeError `ERR_INVALID_ARG_TYPE` if `src` is not a string
  */
+/**
+ * Emit scan.l's chkNum warnings for every badly delimited number the lexer
+ * reaches: all of them on success, those at or before a syntax error otherwise
+ * (C's lexer stops there). @see lib/cgraph/scan.l:chkNum
+ */
+function warnNumberAmbiguities(src: string, upTo: number): void {
+  for (const a of scanNumberAmbiguities(src, Stripper.strip(src))) {
+    if (a.offset > upTo) break;
+    console.error(numberAmbiguityMessage(a));
+  }
+}
+
 export function parse(src: string): Graph {
   if (typeof src !== 'string') {
     // Runtime guard for JS callers (the TS signature already forbids this):
@@ -235,6 +248,7 @@ export function parse(src: string): Graph {
   } catch (err: unknown) {
     if (isPeggyError(err)) {
       const start = err.location.start;
+      warnNumberAmbiguities(src, start.offset);
       const code: GvErrorCode =
         err.found === null ? 'SYNTAX_UNEXPECTED_EOF' : 'SYNTAX_ERROR';
       throw new ParseError(
@@ -256,6 +270,7 @@ export function parse(src: string): Graph {
     }
     throw err;
   }
+  warnNumberAmbiguities(src, src.length);
   validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }

package/src/parser/number-scan.ts

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * scan.l's chkNum diagnostics. The NUMBER regexp allows one trailing '.' or
+ * LETTER so the lexer can catch a number run into a name (`00splines`) or a
+ * second dot (`1.2.3`); chkNum then warns and yyless() hands the last
+ * character back, splitting the text into two tokens. The PEG grammar already
+ * yields the split tokens; this pass reproduces the warnings, which a
+ * backtracking PEG action would emit unreliably (an alternative that fails
+ * after matching a number would re-run it).
+ *
+ * The walk runs over Stripper output (comments and string interiors blanked,
+ * same length, newlines kept), lexing the INITIAL-state tokens that can
+ * contain or abut a number: NAME, NUMBER, and the `--` / `->` edge operators.
+ *
+ * @see lib/cgraph/scan.l:106-110 (LETTER, DIGIT, NAME, NUMBER), :135, chkNum
+ */
+
+/** One chkNum warning: the matched NUMBER text and its line. */
+export interface NumberAmbiguity {
+  text: string;
+  line: number;
+  offset: number;
+}
+
+const ASCII_DEL = 0x7f;
+
+/** scan.l LETTER `[A-Za-z_\200-\377]`: any non-ASCII character counts. */
+function isLetter(c: string | undefined): boolean {
+  if (c === undefined) return false;
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_'
+    || c.charCodeAt(0) > ASCII_DEL;
+}
+
+function isDigit(c: string | undefined): boolean {
+  return c !== undefined && c >= '0' && c <= '9';
+}
+
+/** True when a NUMBER starts at i (sign, digits, or a dot before a digit). */
+function startsNumber(s: string, i: number): boolean {
+  const c = s[i];
+  if (isDigit(c)) return true;
+  if (c === '.') return isDigit(s[i + 1]);
+  if (c !== '-') return false;
+  return isDigit(s[i + 1]) || (s[i + 1] === '.' && isDigit(s[i + 2]));
+}
+
+/** End index of the longest NUMBER match starting at i (scan.l:109). */
+function matchNumber(s: string, i: number): number {
+  let j = s[i] === '-' ? i + 1 : i;
+  if (s[j] === '.') {
+    j++;
+    while (isDigit(s[j])) j++;
+  } else {
+    while (isDigit(s[j])) j++;
+    if (s[j] === '.') {
+      j++;
+      while (isDigit(s[j])) j++;
+    }
+  }
+  if (s[j] === '.' || isLetter(s[j])) j++;
+  return j;
+}
+
+/** scan.l twoDots: the first '.' is not the last character. */
+function twoDots(text: string): boolean {
+  const dot = text.indexOf('.');
+  return dot !== -1 && dot !== text.length - 1;
+}
+
+/** scan.l chkNum: the last character is a letter, or a second '.'. */
+function chkNum(text: string): boolean {
+  const c = text[text.length - 1]!;
+  return (!isDigit(c) && c !== '.') || (c === '.' && twoDots(text));
+}
+
+/**
+ * Lex one INITIAL token at i; returns the next index and, for a badly
+ * delimited NUMBER, its text (the next index is then yyless'd back by one).
+ */
+function lexToken(s: string, i: number): { next: number; bad: string | null } {
+  if (isLetter(s[i])) {
+    let j = i + 1;
+    while (isLetter(s[j]) || isDigit(s[j])) j++;
+    return { next: j, bad: null };
+  }
+  if (s[i] === '-' && (s[i + 1] === '-' || s[i + 1] === '>')) return { next: i + 2, bad: null };
+  if (!startsNumber(s, i)) return { next: i + 1, bad: null };
+  const j = matchNumber(s, i);
+  const text = s.slice(i, j);
+  return chkNum(text) ? { next: j - 1, bad: text } : { next: j, bad: null };
+}
+
+/**
+ * Every badly delimited NUMBER in `src`, in lexing order. `stripped` is
+ * Stripper.strip(src) (same length); tokens are lexed from it, lines are
+ * counted in `src` (the stripper blanks newlines inside comments and strings,
+ * which scan.l still counts). @see lib/cgraph/scan.l:chkNum
+ */
+export function scanNumberAmbiguities(src: string, stripped: string): NumberAmbiguity[] {
+  const out: NumberAmbiguity[] = [];
+  let line = 1;
+  let lineAt = 0;
+  for (let i = 0; i < stripped.length;) {
+    const { next, bad } = lexToken(stripped, i);
+    if (bad !== null) {
+      for (; lineAt < i; lineAt++) if (src[lineAt] === '\n') line++;
+      out.push({ text: bad, line, offset: i });
+    }
+    i = next;
+  }
+  return out;
+}
+
+/** agwarningf text for one chkNum ambiguity; a parsed string is "input". */
+export function numberAmbiguityMessage(a: NumberAmbiguity): string {
+  return `Warning: syntax ambiguity - badly delimited number '${a.text}' in line ${a.line} of input splits into two tokens`;
+}

package/src/pathplan/route.ts

@@ -3,6 +3,8 @@
 
 import type { Point, Poly, Edge } from './types.js';
 import { solve3 } from './solvers.js';
+import { fma, fms } from '../common/fma.js';
+import { libmHypot } from '../common/libm-hypot.js';
 
 const EPSILON1 = 1e-3;
 const EPSILON2 = 1e-6;
@@ -18,28 +20,53 @@ class RouteHelper {
   static B1(t: number): number { const u = 1-t; return 3*t*u*u; }
   static B2(t: number): number { const u = 1-t; return 3*t*t*u; }
   static B3(t: number): number { return t*t*t; }
-  static B01(t: number): number { const u = 1-t; return u*u*(u+3*t); }
-  static B23(t: number): number { const u = 1-t; return t*t*(3*u+t); }
+  /** @see lib/pathplan/route.c:B01 */
+  static B01(t: number): number {
+    const u = 1-t;
+    // clang -ffp-contract=on: fmadd at route.c:488 (`tmp + 3*t`)
+    return (u*u) * fma(3, t, u);
+  }
+  /** @see lib/pathplan/route.c:B23 */
+  static B23(t: number): number {
+    const u = 1-t;
+    // clang -ffp-contract=on: fmadd at route.c:494 (`3*tmp + t`)
+    return (t*t) * fma(3, u, t);
+  }
 
+  /** @see lib/pathplan/route.c:normv */
   static normv(v: Point): Point {
-    const d = v.x*v.x + v.y*v.y;
+    // clang -ffp-contract=on: fmadd at route.c:413 (v.x*v.x fused, v.y*v.y rounded)
+    const d = fma(v.x, v.x, v.y*v.y);
     if (d > 1e-6) { const s = Math.sqrt(d); return { x: v.x/s, y: v.y/s }; }
     return v;
   }
   static ptAdd(a: Point, b: Point): Point { return { x: a.x+b.x, y: a.y+b.y }; }
   static ptSub(a: Point, b: Point): Point { return { x: a.x-b.x, y: a.y-b.y }; }
   static ptScale(p: Point, c: number): Point { return { x: p.x*c, y: p.y*c }; }
-  static ptDot(a: Point, b: Point): number { return a.x*b.x + a.y*b.y; }
-  static ptDist(a: Point, b: Point): number { return Math.hypot(a.x-b.x, a.y-b.y); }
+  /** @see lib/pathplan/route.c:dot */
+  static ptDot(a: Point, b: Point): number {
+    // clang -ffp-contract=on: fmadd at route.c:459 (p1.x*p2.x fused, p1.y*p2.y rounded)
+    return fma(a.x, b.x, a.y*b.y);
+  }
+  /** @see lib/pathplan/route.c:dist (libm hypot, no contraction) */
+  static ptDist(a: Point, b: Point): number { return libmHypot(a.x-b.x, a.y-b.y); }
   static distN(pts: Point[]): number {
     let rv = 0;
     for (let i = 1; i < pts.length; i++) rv += RouteHelper.ptDist(pts[i], pts[i-1]);
     return rv;
   }
 
+  /**
+   * The cubic's coefficients come out of catastrophic cancellation when the
+   * spline is tangent to a barrier (tests/2646.dot), so clang's contraction
+   * here decides solve3's root count; mirror it exactly.
+   * @see lib/pathplan/route.c:points2coeff
+   */
   static points2coeff(v0: number, v1: number, v2: number, v3: number, c: number[]): void {
-    c[3] = v3 + 3*v1 - (v0 + 3*v2);
-    c[2] = 3*v0 + 3*v2 - 6*v1;
+    // clang -ffp-contract=on: fmadd x2 at route.c:397 (`v3 + 3*v1`, `v0 + 3*v2`; outer sub rounded)
+    c[3] = fma(3, v1, v3) - fma(3, v2, v0);
+    // clang -ffp-contract=on: fmadd at route.c:398 (`3*v0` fused onto rounded `3*v2`, then `- 6*v1` fused)
+    c[2] = fma(-6, v1, fma(3, v0, 3*v2));
     c[1] = 3*(v1 - v0);
     c[0] = v0;
   }
@@ -79,7 +106,8 @@ class RouteHelper {
       const tv = xr[i];
       if (tv >= 0 && tv <= 1) {
         RouteHelper.points2coeff(sps[0].y, sps[1].y, sps[2].y, sps[3].y, sc);
-        const sv = (sc[0] + tv*(sc[1] + tv*(sc[2] + tv*sc[3])) - lc.yc0) / lc.yc1;
+        // clang -ffp-contract=on: fmadd x3 at route.c:360-361 (Horner `sv`; `(sv - ycoeff[0]) / ycoeff[1]` plain)
+        const sv = (fma(tv, fma(tv, fma(tv, sc[3], sc[2]), sc[1]), sc[0]) - lc.yc0) / lc.yc1;
         if (sv >= 0 && sv <= 1) RouteHelper.addRoot(tv, acc);
       }
     }
@@ -89,23 +117,27 @@ class RouteHelper {
   static silGeneral(sps: Point[], lc: LineCoeff, acc: RootAccum): number {
     const sc = [0,0,0,0], xr = [0,0,0];
     const rat = lc.yc1 / lc.xc1;
+    // clang -ffp-contract=on: fmsub x4 at route.c:371-372 (`sps[k].y - rat*sps[k].x`)
     RouteHelper.points2coeff(
-      sps[0].y - rat*sps[0].x, sps[1].y - rat*sps[1].x,
-      sps[2].y - rat*sps[2].x, sps[3].y - rat*sps[3].x, sc);
-    sc[0] += rat*lc.xc0 - lc.yc0;
+      fms(rat, sps[0].x, sps[0].y), fms(rat, sps[1].x, sps[1].y),
+      fms(rat, sps[2].x, sps[2].y), fms(rat, sps[3].x, sps[3].y), sc);
+    // clang -ffp-contract=on: fnmsub at route.c:374 (`rat*xcoeff[0] - ycoeff[0]`; `+=` rounded)
+    sc[0] += fma(rat, lc.xc0, -lc.yc0);
     const xn = solve3(sc, xr);
     if (xn === 4) return 4;
     for (let i = 0; i < xn; i++) {
       const tv = xr[i];
       if (tv >= 0 && tv <= 1) {
         RouteHelper.points2coeff(sps[0].x, sps[1].x, sps[2].x, sps[3].x, sc);
-        const sv = (sc[0] + tv*(sc[1] + tv*(sc[2] + tv*sc[3])) - lc.xc0) / lc.xc1;
+        // clang -ffp-contract=on: fmadd x3 at route.c:383-384 (Horner `sv`; `(sv - xcoeff[0]) / xcoeff[1]` plain)
+        const sv = (fma(tv, fma(tv, fma(tv, sc[3], sc[2]), sc[1]), sc[0]) - lc.xc0) / lc.xc1;
         if (sv >= 0 && sv <= 1) RouteHelper.addRoot(tv, acc);
       }
     }
     return acc.n;
   }
 
+  /** @see lib/pathplan/route.c:splineintersectsline */
   static splineIntersectsLine(sps: Point[], lps: Point[], roots: number[]): number {
     const lc: LineCoeff = {
       xc0: lps[0].x, xc1: lps[1].x - lps[0].x,
@@ -156,8 +188,13 @@ class RouteHelper {
       x0 += RouteHelper.ptDot(tnas[i].a[0], tmp);
       x1 += RouteHelper.ptDot(tnas[i].a[1], tmp);
     }
-    const det01 = c00*c11 - c01*c01;
-    const detX1 = x0*c11 - x1*c01, det0X = c00*x1 - c01*x0;
+    // C's c[1][0] is a copy of c[0][1] (route.c:174), so c10 == c01 here.
+    // clang -ffp-contract=on: fnmul+fmadd at route.c:181 (c00*c11 fused, c10*c01 rounded)
+    const det01 = fma(c00, c11, -(c01*c01));
+    // clang -ffp-contract=on: fnmul+fmadd at route.c:182 (c00*x1 fused, c01*x0 rounded)
+    const det0X = fma(c00, x1, -(c01*x0));
+    // clang -ffp-contract=on: fnmul+fmadd at route.c:183 (x0*c11 fused, x1*c01 rounded)
+    const detX1 = fma(x0, c11, -(x1*c01));
     if (Math.abs(det01) >= 1e-6) { scale0 = detX1/det01; scale3 = det0X/det01; }
     if (Math.abs(det01) < 1e-6 || scale0 <= 0 || scale3 <= 0) {
       const d = RouteHelper.ptDist(inps[0], inps[n-1]) / 3;
@@ -179,6 +216,27 @@ class RouteHelper {
     return tnas;
   }
 
+  /**
+   * The max-deviation split of `reallyroutespline` (route.c:130-143): the
+   * interior polyline point farthest from the fitted bezier.
+   *
+   * Faithful contract. On a geometrically symmetric channel two interior
+   * deviations tie to within an ulp, so the split point (and the whole
+   * spline) is decided by C's exact arithmetic, which this mirrors bit for
+   * bit against the native arm64 oracle:
+   * - `dist` is libm `hypot` (route.c:448) -> `libmHypot` via `ptDist`;
+   * - the test is C's strict `(d = dist(p, inps[i])) > maxd` (route.c:139),
+   *   so an exact tie keeps the first index;
+   * - clang's default `-ffp-contract=on` fuses the bezier eval at
+   *   route.c:137-138 as `fma(B3,p2, fma(B2,cp2, fma(B0,p1, B1*cp1)))`; the
+   *   B0..B3 weights and cp1/cp2 (route.c:130-131) are not fused. Fusing the
+   *   other product first is NOT equivalent (flips pt-issue-23-w9 and 32).
+   * C is therefore not translation-equivariant on such ties (the winner
+   * depends on absolute-coordinate rounding), and neither is this port.
+   * This supersedes the former tolerant tie-break (accepted divergence A3).
+   * Contraction map: .agent-notes/pathplan-fma-contraction-map.md.
+   * @see lib/pathplan/route.c:reallyroutespline
+   */
   static findMaxDev(inps: Point[], tnas: Tna[], ends: SplineEndpoints): number {
     const { p0, v0, p1, v1 } = ends;
     const cp1 = RouteHelper.ptAdd(p0, RouteHelper.ptScale(v0, 1/3));
@@ -186,27 +244,14 @@ class RouteHelper {
     let maxi = -1, maxd = -1;
     for (let i = 1; i < inps.length - 1; i++) {
       const t = tnas[i].t;
-      const px = RouteHelper.B0(t)*p0.x + RouteHelper.B1(t)*cp1.x + RouteHelper.B2(t)*cp2.x + RouteHelper.B3(t)*p1.x;
-      const py = RouteHelper.B0(t)*p0.y + RouteHelper.B1(t)*cp1.y + RouteHelper.B2(t)*cp2.y + RouteHelper.B3(t)*p1.y;
+      const b0 = RouteHelper.B0(t), b1 = RouteHelper.B1(t);
+      const b2 = RouteHelper.B2(t), b3 = RouteHelper.B3(t);
+      // clang -ffp-contract=on: fmadd at route.c:137 (x3; B1*cp1.x rounded first)
+      const px = fma(b3, p1.x, fma(b2, cp2.x, fma(b0, p0.x, b1*cp1.x)));
+      // clang -ffp-contract=on: fmadd at route.c:138 (x3; B1*cp1.y rounded first)
+      const py = fma(b3, p1.y, fma(b2, cp2.y, fma(b0, p0.y, b1*cp1.y)));
       const d = RouteHelper.ptDist({ x: px, y: py }, inps[i]);
-      // C `reallyroutespline` uses strict `if (d > maxd)`. On a geometrically
-      // SYMMETRIC channel the two interior deviations are an exact tie, and the
-      // winner is then decided by ~1e-14 cancellation noise in the
-      // absolute-coordinate bezier eval above — whose sign depends on absolute
-      // position. So C is NOT consistent: it splits two translation-congruent
-      // arcs toward opposite corners (e.g. 2368 `376->76` mirrors `256->436`),
-      // because Apple's macOS libm `hypot` (which generated the oracle) is a
-      // proprietary ~1-ULP-divergent implementation that no portable hypot
-      // reproduces. We deliberately keep the tolerant tie-break: a true tie
-      // always resolves to the first index, so the port is TRANSLATION-
-      // EQUIVARIANT (same channel anywhere -> same spline). This matches C where
-      // C's noise also keeps-first (#241_0 5:ne->8:nw, and the cnt=3 oracle
-      // case) and consciously diverges where C's noise keeps-second (2368
-      // `376->76`, the lone surviving residual: structural-match, maxΔ ~10pt on
-      // one flat-edge arc). See .agent-notes/2368-residual-flat-label-ranksep.md
-      // and the pow precedent (src/common/arm-pow.ts) for the same Apple-libm
-      // boundary. @see lib/pathplan/route.c:reallyroutespline (max-deviation split)
-      if (d > maxd * (1 + 1e-10) + 1e-10) { maxd = d; maxi = i; }
+      if (d > maxd) { maxd = d; maxi = i; }
     }
     return maxi;
   }

package/src/pathplan/solvers.ts

@@ -1,65 +1,93 @@
 // SPDX-License-Identifier: EPL-2.0
-/** @see lib/pathplan/solvers.c */
+/**
+ * @see lib/pathplan/solvers.c
+ *
+ * The native oracle's libpathplan is compiled by clang with the default
+ * `-ffp-contract=on`, which fuses five multiply-adds in this file into single
+ * fmadd/fmsub/fnmsub instructions (solve2 is inlined into solve3). Those sites
+ * are mirrored with the software `fma`; every other operation is plain IEEE
+ * double, in C's evaluation order. Contraction map:
+ * .agent-notes/pathplan-fma-contraction-map.md.
+ */
 
+import { fma } from '../common/fma.js';
+
+/** @see lib/pathplan/solvers.c:EPS */
 const EPS = 1e-7;
 
-class Solver {
-  static aeq0(x: number): boolean {
-    return x < EPS && x > -EPS;
-  }
+/** @see lib/pathplan/solvers.c:AEQ0 */
+function aeq0(x: number): boolean {
+  return x < EPS && x > -EPS;
+}
 
-  static solve1(c: number[], r: number[]): number {
-    if (Solver.aeq0(c[1])) return Solver.aeq0(c[0]) ? 4 : 0;
-    r[0] = -c[0] / c[1];
-    return 1;
-  }
+/**
+ * Solve cubic coeff[3]*x^3 + coeff[2]*x^2 + coeff[1]*x + coeff[0] = 0.
+ * Returns the root count; 4 means every x satisfies.
+ * @see lib/pathplan/solvers.c:solve3
+ */
+export function solve3(coeff: number[], roots: number[]): number {
+  const a = coeff[3], b = coeff[2], c = coeff[1], d = coeff[0];
+  if (aeq0(a)) return solve2(coeff, roots);
+  const bOver3a = b / (3 * a), cOverA = c / a, dOverA = d / a;
 
-  static solve2(c: number[], r: number[]): number {
-    if (Solver.aeq0(c[2])) return Solver.solve1(c, r);
-    const b2a = c[1] / (2 * c[2]);
-    const disc = b2a * b2a - c[0] / c[2];
-    if (disc < 0) return 0;
-    if (disc > 0) {
-      r[0] = -b2a + Math.sqrt(disc);
-      r[1] = -2 * b2a - r[0];
-      return 2;
-    }
-    r[0] = -b2a;
-    return 1;
-  }
+  let p = bOver3a * bOver3a;
+  // clang -ffp-contract=on: fnmul+fmadd at solvers.c:41 (`2*b_over_3a*p` fused,
+  // `b_over_3a*c_over_a` rounded; `+ d_over_a` is a separate rounded add)
+  const q = dOverA + fma(2 * bOver3a, p, -(bOver3a * cOverA));
+  p = cOverA / 3 - p;
+  // clang -ffp-contract=on: fmadd at solvers.c:43 (q*q fused, 4*p*p*p rounded)
+  const disc = fma(q, q, 4 * p * p * p);
 
-  static solve3neg(disc: number, q: number, b3a: number, r: number[]): number {
-    const rr = 0.5 * Math.sqrt(-disc + q * q);
+  let rootn: number;
+  if (disc < 0) {
+    // clang -ffp-contract=on: fnmsub at solvers.c:46 (`-disc + q*q`)
+    const r = 0.5 * Math.sqrt(fma(q, q, -disc));
     const theta = Math.atan2(Math.sqrt(-disc), -q);
-    const temp = 2 * Math.cbrt(rr);
-    r[0] = temp * Math.cos(theta / 3) - b3a;
-    r[1] = temp * Math.cos((theta + 2 * Math.PI) / 3) - b3a;
-    r[2] = temp * Math.cos((theta - 2 * Math.PI) / 3) - b3a;
-    return 3;
+    const temp = 2 * Math.cbrt(r);
+    roots[0] = temp * Math.cos(theta / 3);
+    roots[1] = temp * Math.cos((theta + Math.PI + Math.PI) / 3);
+    roots[2] = temp * Math.cos((theta - Math.PI - Math.PI) / 3);
+    rootn = 3;
+  } else {
+    const alpha = 0.5 * (Math.sqrt(disc) - q);
+    const beta = -q - alpha;
+    roots[0] = Math.cbrt(alpha) + Math.cbrt(beta);
+    if (disc > 0) rootn = 1;
+    else { roots[1] = roots[2] = -0.5 * roots[0]; rootn = 3; }
   }
 
-  static solve3pos(disc: number, q: number, b3a: number, r: number[]): number {
-    const al = 0.5 * (Math.sqrt(disc) - q);
-    r[0] = Math.cbrt(al) + Math.cbrt(-q - al) - b3a;
-    if (disc > 0) return 1;
-    r[1] = r[2] = -0.5 * (r[0] + b3a) - b3a;
-    return 3;
-  }
+  for (let i = 0; i < rootn; i++) roots[i] -= bOver3a;
+  return rootn;
+}
+
+/** @see lib/pathplan/solvers.c:solve2 */
+function solve2(coeff: number[], roots: number[]): number {
+  const a = coeff[2], b = coeff[1], c = coeff[0];
+  if (aeq0(a)) return solve1(coeff, roots);
+  const bOver2a = b / (2 * a);
+  const cOverA = c / a;
 
-  static solve3(c: number[], r: number[]): number {
-    const a = c[3], b = c[2], cv = c[1], d = c[0];
-    if (Solver.aeq0(a)) return Solver.solve2(c, r);
-    const b3a = b / (3 * a), p0 = b3a * b3a;
-    const q = 2 * b3a * p0 - b3a * cv / a + d / a;
-    const p = cv / (3 * a) - p0;
-    const disc = q * q + 4 * p * p * p;
-    return disc < 0 ? Solver.solve3neg(disc, q, b3a, r)
-                    : Solver.solve3pos(disc, q, b3a, r);
+  // clang -ffp-contract=on: fmadd at solvers.c:80 (`b_over_2a*b_over_2a - c_over_a`)
+  const disc = fma(bOver2a, bOver2a, -cOverA);
+  if (disc < 0) {
+    return 0;
+  } else if (disc > 0) {
+    roots[0] = -bOver2a + Math.sqrt(disc);
+    // clang -ffp-contract=on: fnmsub at solvers.c:85 (`-2*b_over_2a - roots[0]`)
+    roots[1] = fma(-2, bOver2a, -roots[0]);
+    return 2;
   }
+  roots[0] = -bOver2a;
+  return 1;
 }
 
-/** Solve cubic c[3]*x^3 + c[2]*x^2 + c[1]*x + c[0] = 0.
- *  Returns root count; 4 means all x satisfy. @see lib/pathplan/solvers.c:solve3 */
-export function solve3(coeff: number[], roots: number[]): number {
-  return Solver.solve3(coeff, roots);
+/** @see lib/pathplan/solvers.c:solve1 (no contraction) */
+function solve1(coeff: number[], roots: number[]): number {
+  const a = coeff[1], b = coeff[0];
+  if (aeq0(a)) {
+    if (aeq0(b)) return 4;
+    return 0;
+  }
+  roots[0] = -b / a;
+  return 1;
 }

package/src/render/dot/edge-draw.ts

@@ -18,6 +18,7 @@ import type { ArrowDrawOp } from '../../common/arrows-types.js';
 import type { GVColor } from '../../common/color.js';
 import type { RenderJob } from '../../gvc/job.js';
 import { EmitState } from '../../gvc/job.js';
+import { PenType } from '../../gvc/context.js';
 import { resolveRenderColor } from '../color-resolve.js';
 import { taper, taperfun } from '../../common/taper.js';
 import { orthoRoundedRadius } from '../svg-helpers.js';
@@ -31,6 +32,9 @@ import { DotWriterBase } from './agwrite.js';
 /** Pen colour when a colour-list entry is empty. @see lib/common/emit.c:2485 */
 const DEFAULT_COLOR = 'black';
 
+/** gvc->defaultlinestyle as style tokens. @see lib/common/emit.c:105 */
+const DEFAULT_LINE_STYLE: readonly string[] = ['solid', 'setlinewidth(1)'];
+
 /**
  * One arrow primitive as an xdot op. Lifted out of emitArrows' loop unchanged —
  * the four cases and their `filled` variants are exactly arrow_gen's.
@@ -64,6 +68,27 @@ export abstract class EdgeDrawBase extends DotWriterBase {
   protected penwidth: number[] = new Array(12).fill(1);
   protected abstract styleOp(job: RenderJob): string;
   protected abstract penOp(job: RenderJob): string;
+  abstract polyline(pts: Point[], job: RenderJob): void;
+
+  /**
+   * emit_attachment's draw calls (decorate=true): gvrender_set_style with the
+   * default line style sets the obj's rawstyle/pen/penwidth (setlinewidth 1),
+   * gvrender_set_pencolor sets the pen to the label fontcolor (first entry of
+   * a color list), then gvrender_polyline → xdot_polyline emits the style ops
+   * (`S 5 -solid`; setlinewidth is filtered), the pen color and `L 3`.
+   * @see lib/common/emit.c:emit_attachment (1886-1893)
+   * @see lib/gvc/gvrender.c:gvrender_set_style / gvrender_set_pencolor
+   */
+  attachmentPolyline(pts: Point[], pencolor: string, job: RenderJob): void {
+    const obj = job.obj;
+    if (obj !== null) {
+      obj.rawStyle = [...DEFAULT_LINE_STYLE];
+      obj.pen = PenType.Solid;
+      obj.penWidth = 1;
+      obj.penColor = resolveRenderColor(pencolor.split(':')[0]!);
+    }
+    this.polyline(pts, job);
+  }
 
   /**
    * The plain single-colour spline branch of beginEdge — lifted verbatim so the