@knowvah/dot-engine 2.6.10 → 2.6.12

package/src/gvc/device.ts

@@ -42,11 +42,14 @@ import {
   styleTokens,
 } from '../common/style-resolve.js';
 import { isPointNode } from '../common/poly-gencode.js';
-import { resolveRenderColor, withColorScheme } from '../render/color-resolve.js';
+import {
+  resolveRenderColor, withColorScheme, reportEdgeColors, reportColorNames, backgroundColors,
+  setRendererKnownColors,
+} from '../render/color-resolve.js';
 import { emitRoundedBezier } from '../common/poly-shapes.js';
 import { applyClusterObjState, clusterStyle, clusterPeripheries } from './device-cluster.js';
 import { transformPoint } from './device-transform.js';
-import { renderOneLabel, renderNodeXLabel, renderClusterLabel } from './device-labels.js';
+import { renderOneLabel, renderNodeXLabel, renderClusterLabel, reportEdgeLabelColors } from './device-labels.js';
 export { transformPoint, applyRotation, applyScale, buildPoint } from './device-transform.js';
 export { renderOneLabel, renderNodeXLabel, renderClusterLabel } from './device-labels.js';
 import { svgNodeId, svgEdgeId, svgClusterId, svgGraphId } from '../render/svg-id.js';
@@ -156,7 +159,7 @@ function setEdgePen(e: Edge, job: RenderJob): void {
   const obj = job.obj;
   const flags = parseStyleFlags(e.attrs.get('style'));
   obj.penColor = withColorScheme(e.attrs.get('colorscheme'),
-    () => resolveRenderColor(resolvePenColor(e.attrs.get('color'))));
+    () => resolveRenderColor(resolvePenColor(e.attrs.get('color')), false));
   obj.pen = resolvePenType(flags);
   obj.penWidth = resolvePenWidth(flags, e.attrs.get('penwidth'));
   // Raw style tokens for xdot's `S` ops (e.g. explicit style="solid"); SVG
@@ -189,6 +192,10 @@ export function renderEdge(e: Edge, renderer: RendererPlugin, job: RenderJob): v
     // @see lib/common/emit.c:emit_edge (begin/end color context)
     withColorScheme(e.attrs.get('colorscheme'), () => {
       renderer.beginEdge(e, job);
+      // emit_edge_graphics, then emit_end_edge's labels: C resolves these names
+      // here whatever the renderer draws (the non-drawing ones included).
+      reportEdgeColors(e);
+      reportEdgeLabelColors(e);
       renderer.endEdge(e, job);
     });
   } finally {
@@ -351,9 +358,13 @@ function renderPage(g: Graph, renderer: RendererPlugin, job: RenderJob, info: La
     resolveObjAnchor(g, labelTextOf(g.info.label), svgGraphId(g, job), job.obj);
   }
   const anchored = beginAnchorIf(renderer, job);
-  renderer.pageBackground?.(g, job);
-  // emit root-graph label before clusters/nodes @see lib/common/emit.c:emit_page
-  renderGraphLabel(g, renderer, job);
+  // emit_page opens the graph's colorscheme around the background and label.
+  withColorScheme(g.attrs.get('colorscheme'), () => {
+    reportColorNames(backgroundColors(g.attrs.get('bgcolor'), renderer.type === 'svg'));
+    renderer.pageBackground?.(g, job);
+    // emit root-graph label before clusters/nodes @see lib/common/emit.c:emit_page
+    renderGraphLabel(g, renderer, job);
+  });
   if (anchored) renderer.endAnchor?.(job);
   // emit_view: clusters are drawn BEFORE nodes/edges normally, but the map
   // device (EMIT_CLUSTERS_LAST) emits their <area> AFTER, so a node/edge area
@@ -459,6 +470,7 @@ export function render(ctx: GvcContext, g: Graph, format: string, inlineImages =
   // @see lib/common/emit.c:3260 (gvc->rotation=90); :3390 (job->rotation)
   job.rotation = parseLandscape(g) ? 90 : 0;
   job.renderer = renderer;
+  setRendererKnownColors(renderer.type === 'svg'); // svg_knowncolors; others have none
   resetHtmlAnchorIds(); // C: fresh anchorId per dot invocation
   for (const n of g.nodes.values()) polyInit(n, g, job.measurer);
   return renderGraph(g, job, renderer);

package/src/index.ts

@@ -22,6 +22,7 @@ import type { GvError, RenderResult } from './errors.js';
 import type { EngineName } from './gvc/context.js';
 import { render as deviceRender } from './gvc/device.js';
 import { createDefaultContext } from './gvc/default-context.js';
+import { resetRenderState } from './common/render-state.js';
 
 
 
@@ -90,6 +91,7 @@ function classifyError(err: unknown): GvError {
  */
 export function renderSvg(dotSource: string, engine: EngineName): string {
   checkRenderArgs(dotSource, engine);
+  resetRenderState(); // AD-4: one render = one native process
   const ctx = createDefaultContext();
   try {
     // parse() is inside the try so any non-ParseError throw (e.g. a raw
@@ -122,6 +124,7 @@ export function renderSvg(dotSource: string, engine: EngineName): string {
 export function tryRenderSvg(dotSource: string, engine: EngineName): RenderResult {
   checkRenderArgs(dotSource, engine);
   try {
+    // renderSvg calls resetRenderState first (AD-4).
     return { svg: renderSvg(dotSource, engine) };
   } catch (err: unknown) {
     if (isUsageError(err)) throw err;

package/src/layout/dot/cluster.ts

@@ -27,6 +27,7 @@ import { CLUSTER } from './rank.js';
 import { makeSlots, safeOtherEdge, makeInterclustChain } from './cluster-path.js';
 // mergeChain lives in classify.ts (circular: classify ↔ cluster — safe for function refs)
 import { mergeChain, portsEq } from './classify.js';
+import { agwarningf } from '../../common/agerr.js';
 
 export { CLUSTER_EDGE } from './cluster-path.js';
 export { mapInterclustNode } from './cluster-path.js';
@@ -297,7 +298,7 @@ export function markClusterNode(clust: Graph, n: Node, g: Graph): void {
   if ((n.info.ranktype ?? 0) !== 0) {
     // C warns with the ENCLOSING graph's name, not the cluster's.
     // @see lib/dotgen/cluster.c:317-320
-    console.error(`Warning: ${n.name} was already in a rankset, deleted from cluster ${g.name}`);
+    agwarningf(`${n.name} was already in a rankset, deleted from cluster ${g.name}`, 'error');
     agDeleteFromCluster(clust, n);
     return;
   }

package/src/layout/dot/conc.ts

@@ -20,6 +20,7 @@ import { dotScanRanks } from './rank.js';
 import { dotRoot, rankGet } from './mincross-utils.js';
 import { nodesInSeq } from './decomp.js';
 import { graphMinrank, graphMaxrank } from './position-aux.js';
+import { agerr, agerrorf, agwarningf } from '../../common/agerr.js';
 
 const UP = 0;
 const DOWN = 1;
@@ -263,13 +264,13 @@ export function fillRankVlist(g: Graph, r: number, root: Graph): number {
   const rankArr = g.info.rank!;
   const lead = g.info.rankleader![r];
   if (lead === undefined || lead === null) {
-    console.error(`Error: rebuild_vlists: lead is null for rank ${r}`);
+    agerrorf(`rebuild_vlists: lead is null for rank ${r}`);
     return -1;
   }
   const rootRank = root.info.rank![r];
   if (rootRank.v[lead.info.order ?? 0] !== lead) {
-    console.error(
-      `Error: rebuild_vlists: rank lead ${lead.name} not in order ` +
+    agerrorf(
+      `rebuild_vlists: rank lead ${lead.name} not in order ` +
       `${lead.info.order ?? 0} of rank ${r}`,
     );
     return -1;
@@ -292,7 +293,7 @@ export function fillRankVlist(g: Graph, r: number, root: Graph): number {
   rankArr[r].v = rootRank.v;
   rankArr[r].vStart = lead.info.order ?? 0;
   const maxi = computeMaxi(g, r);
-  if (maxi === -1) console.error(`Warning: degenerate concentrated rank ${g.name},${r}`);
+  if (maxi === -1) agwarningf(`degenerate concentrated rank ${g.name},${r}`, 'error');
   rankArr[r].n = maxi + 1;
   return 0;
 }
@@ -425,7 +426,7 @@ export function dotConcentrate(g: Graph): number {
   const clust = g.info.clust ?? [];
   for (let c = 0; c < nCluster; c++) {
     if (rebuildVlists(clust[c]) !== 0) {
-      console.error('concentrate=true may not work correctly.');
+      agerr('prev', 'concentrate=true may not work correctly.');
       return -1;
     }
   }

package/src/layout/dot/decomp.ts

@@ -3,6 +3,7 @@
 import type { Node } from '../../model/node.js';
 import type { Graph } from '../../model/graph.js';
 import type { EdgeList } from '../../model/nodeInfo.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 // ---------------------------------------------------------------------------
 // AGSEQ-order node iteration (agfstnode/agnxtnode mirror)
@@ -135,7 +136,9 @@ export function decompSearch(g: Graph, start: Node, cmark: number): void {
 }
 
 // Cmark as const-object property avoids module-level let that confuses Lizard.
+/** @see lib/dotgen/decomp.c:Cmark (C static, 0 at process start) */
 const _dc = { cmark: 0 };
+registerRenderState(() => { _dc.cmark = 0; });
 
 // ONE private function immediately before decompose — the acyclic.ts pattern.
 function resolveNode(n: Node, pass: 0 | 1): Node | undefined {

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

@@ -12,6 +12,7 @@ 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';
+import { fma } from '../../common/fma.js';
 
 // ---------------------------------------------------------------------------
 // De Casteljau subdivision
@@ -115,17 +116,30 @@ export function bezierClipNode(
 }
 
 /**
- * Clip the path endpoint to the arrowhead BASE (not node boundary).
- *
- * Ports lib/common/arrows.c:arrowEndClip.
- * The path ends at arrowhead-BASE (arrowTip + elen toward tail), not at the
- * node boundary. The arrowTip (spl.ep) is the node-boundary clip result.
+ * DIST(p, q) = sqrt(SQR(dx) + SQR(dy)) as the oracle compiles it
+ * (libgvc 16.1 `_arrowEndClip`: `fmul dy*dy; fmadd dx, dx; fsqrt`), i.e.
+ * sqrt(fma(dx, dx, dy * dy)) -- not Math.hypot.
+ * @see lib/common/geom.h:DIST
+ */
+export function distFused(p: Point, q: Point): number {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return Math.sqrt(fma(dx, dx, dy * dy));
+}
+
+/**
+ * Clip the path endpoint to the arrowhead BASE (not the node boundary).
  *
- * Steps (matching C arrowEndClip):
- * 1. Reverse the last Bezier segment: sp[0]=arrowTip, sp[1..3]=reversed path
- * 2. inside = DIST(p, arrowTip) <= elen (arrowhead sphere)
- * 3. bezierClip with left_inside=true (sp[0]=arrowTip is "inside" the sphere)
- * 4. Un-reverse the clipped right subdivision → path ends at arrowhead BASE
+ * Ports the bezier part of lib/common/arrows.c:arrowEndClip (:285-330); the
+ * `spl->eflag/ep` bookkeeping and the `endp -= 3` back-up (:288-296) live in
+ * the callers (compound.ts:arrowEndClipIdx). Line map (C -> here):
+ *   :299-302 sp[3..0] = ps[endp..], sp[0] = spl->ep -> `sp` below
+ *   :304     if (elen > 0)                           -> `elen > 0`
+ *   :305-307 inside_context {p = &sp[0], r = &elen}  -> `inside` (centre = tip)
+ *   :308     bezier_clip(&ctx, inside, sp, true)     -> bezierClipNode, left
+ *            inside, in ABSOLUTE coordinates (centre 0,0), as C does
+ *   :311-314 ps[endp..endp+3] = sp[3..0]             -> returned array
+ *   :281-283 inside(): DIST(p, a.p[0]) <= a.r[0]     -> distFused <= elen
  *
  * @see lib/common/arrows.c:arrowEndClip
  */
@@ -134,18 +148,10 @@ export function arrowEndClip(
   arrowTip: Point,
   elen: number,
 ): Point[] {
-  if (elen <= 0) return path4;
-  // Reverse: sp[0]=tip (inside sphere), sp[1..3]=reversed last 3 path points
   const sp: Point[] = [arrowTip, path4[2]!, path4[1]!, path4[0]!];
-  const insideSphere = (lx: number, ly: number): boolean =>
-    Math.hypot(lx, ly) <= elen;
-  // bezierClipLocal with sp in RELATIVE coords (tip=origin)
-  const spRel: Point[] = sp.map(p => ({ x: p.x - arrowTip.x, y: p.y - arrowTip.y }));
-  const clippedRel = bezierClipLocal(spRel, insideSphere, true);
-  const clipped = clippedRel.map(p => ({ x: p.x + arrowTip.x, y: p.y + arrowTip.y }));
-  // Un-reverse: the clipped right subdivision = [arrowBase, ..., arrowTip]
-  // The path endpoint becomes arrowBase = clipped[0]
-  // Un-reverse the full clipped result; all 4 points update via de Casteljau
+  const clipped = elen > 0
+    ? bezierClipNode(sp, 0, 0, (x, y) => distFused({ x, y }, arrowTip) <= elen, true)
+    : sp;
   return [clipped[3]!, clipped[2]!, clipped[1]!, clipped[0]!];
 }
 

package/src/layout/dot/mincross-build.ts

@@ -40,6 +40,7 @@ export {
   constrainingFlatEdge, countConstraining, postorder,
   flatReorderBuildTemprank, flatReorderFixEdges, flatReorderRank, flatReorder,
 } from './mincross-flat.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 // allocate_ranks — @see lib/dotgen/mincross.c:allocate_ranks
 export function makeEmptyRank(): RankEntry {
@@ -99,6 +100,7 @@ export function allocateRanks(g: Graph): void {
  * distinct names rather than colliding/deduping by name).
  */
 let fillSeq = 0;
+registerRenderState(() => { fillSeq = 0; });
 
 /**
  * Create a placeholder fill node in the `_new_rank` subgraph at `rank`.

package/src/layout/dot/mincross-cross.ts

@@ -18,12 +18,14 @@ import { CLUSTER } from './rank.js';
 import {
   MincrossContext, matrixGet, rankGet,
 } from './mincross-utils.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 /**
  * Mirror of C's file-global `ReMincross`. Set true only during the remincross
  * pass so left2right tightens the cluster constraint. @see mincross.c
  */
 let reMincross = false;
+registerRenderState(() => { reMincross = false; });
 export function setReMincross(b: boolean): void { reMincross = b; }
 
 // ---------------------------------------------------------------------------

package/src/layout/dot/rank.ts

@@ -12,6 +12,7 @@ import { rank } from './ns.js';
 import { dot2Rank } from './rank-dot2.js';
 import { class1 } from './classify.js';
 import { pruneForeignClusterNodes } from './cluster.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 // ---------------------------------------------------------------------------
 // Constants  @see lib/common/const.h
@@ -54,6 +55,7 @@ export const IGNORED = 6;
 /** Global cluster layout type. @see lib/common/globals.h:CL_type */
 export let clType = LOCAL;
 export function setClType(t: number): void { clType = t; }
+registerRenderState(() => { clType = LOCAL; });
 
 // ---------------------------------------------------------------------------
 // Utility helpers

package/src/layout/dot/splines.ts

@@ -26,6 +26,7 @@ import { dispatchOrthoEdges } from './ortho-adapter.js';
 import { routeEdgeGroups } from './splines-groups.js';
 import { placePortLabels, placeRegularEdgeLabels, setEdgeLabelPos } from './splines-label.js';
 import { nodesInSeq } from './decomp.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 // ---------------------------------------------------------------------------
 // Edge-type flag constants
@@ -473,7 +474,7 @@ function orthoDispatch(g: Graph): number {
 function curvedTop(g: Graph): void {
   resetRW(g);
   if (((g.root.info.has_labels ?? 0) & EDGE_LABEL) !== 0) {
-    console.warn('edge labels with splines=curved not supported in dot - use xlabels\n');
+    agerrLineOn('warn', 'edge labels with splines=curved not supported in dot - use xlabels\n');
   }
 }
 

package/src/layout/fdp/index.ts

@@ -27,6 +27,7 @@ import { fdpLayout, mkClusters } from './layout.js';
 import { gdata } from './fdp-model.js';
 import { graphInit } from '../../common/graph-init.js';
 import { csrand } from '../../common/crand.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 export { fdpLayout, mkClusters, evalPositions, setBB } from './layout.js';
 export { fdpTLayout } from './tlayout.js';
@@ -93,7 +94,7 @@ function fdpSplines(g: Graph): void {
       );
     }
     if (g.info.n_cluster_edges) { // HAS_CLUST_EDGE(g)
-      console.warn(CLUSTER_EDGE_WARNING);
+      agerrLineOn('warn', CLUSTER_EDGE_WARNING);
       et = EDGETYPE_LINE;
     } else {
       splineEdges1(g, et);

package/src/layout/fdp/tlayout-parms.ts

@@ -15,6 +15,7 @@
 import type { Graph } from '../../model/graph.js';
 import { lateDouble, lateInt } from '../../common/nodeinit.js';
 import { type XParams, aggetGraph } from './fdp-model.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 // ---------------------------------------------------------------------------
 // Constants — @see lib/fdpgen/tlayout.c:96-101, lib/neatogen/neato.h:27-30
@@ -90,13 +91,19 @@ export interface TParms {
   loopcnt: number;
 }
 
-/** Module-level mutable state, mirroring the C static. @see tlayout.c:parms */
-export const parms: TParms = {
+/** C's zero-initialized static parms_t. */
+const PARMS_INIT: Readonly<TParms> = {
   useGrid: 0, useNew: 0, seed: 0, numIters: 0, maxIters: 0, unscaled: 0,
   C: 0, Tfact: 0, K: 0, T0: 0, smode: 0, Cell: 0, Wd: 0, Ht: 0,
   pass1: 0, loopcnt: 0,
 };
 
+/** Module-level mutable state, mirroring the C static. @see tlayout.c:parms */
+export const parms: TParms = { ...PARMS_INIT };
+// fdpParms is not reset: it is the -L command-line configuration (args.c),
+// and the one field a render writes (K) is set by fdpInitParams before any read.
+registerRenderState(() => { Object.assign(parms, PARMS_INIT); });
+
 /** Linear cooling schedule. @see lib/fdpgen/tlayout.c:cool */
 export function cool(t: number): number {
   return parms.T0 * (parms.maxIters - t) / parms.maxIters;

package/src/layout/fdp/xlayout.ts

@@ -36,6 +36,7 @@ import { libmHypot } from '../../common/libm-hypot.js';
 import { fma, fms } from '../../common/fma.js';
 import { normalizeG } from './normalize.js';
 import { simpleScale } from '../neato/simple-scale.js';
+import { registerRenderState } from '../../common/render-state.js';
 
 /** @see lib/fdpgen/xlayout.c:DFLT_overlap */
 const DFLT_OVERLAP = '9:prism';
@@ -47,8 +48,8 @@ const PS2INCH = (x: number): number => x / 72;
 // xParams / X_marg — static state (C statics, persist across calls)
 // ---------------------------------------------------------------------------
 
-/** @see lib/fdpgen/xlayout.c:xParams */
-const xParams: XParams = {
+/** C's static initializer of xParams. @see lib/fdpgen/xlayout.c:xParams */
+const XPARAMS_INIT: Readonly<XParams> = {
   numIters: 60,
   T0: 0.0,
   K: 0.3,
@@ -56,8 +57,15 @@ const xParams: XParams = {
   loopcnt: 0,
 };
 
+/** @see lib/fdpgen/xlayout.c:xParams */
+const xParams: XParams = { ...XPARAMS_INIT };
+
 /** @see lib/fdpgen/xlayout.c:X_marg */
 let xMarg: ExpandT = { x: 0, y: 0, doAdd: false };
+registerRenderState(() => {
+  Object.assign(xParams, XPARAMS_INIT);
+  xMarg = { x: 0, y: 0, doAdd: false };
+});
 
 /** Overlap/non-overlap repulsion strengths for one try. */
 interface RepStrength {

package/src/layout/neato/cdt-surface.ts

@@ -354,14 +354,14 @@ class Cdt {
 
     if (this.inCircle(v1, v2, v3, v4) > 0) {
       const en = this.edgeOrNew(v3, v4);
-      // f3 ring: (v4, v2, v3) with edges (e5, e2, en); e5 = v4–v2
-      // f4 ring: (v1, v4, v3) with edges (e4, en, e3); e4 = v1–v4
-      // (rings derived from C's gts_face_new(en,e5,e2)/(en,e3,e4) cycles,
-      //  matching the vertex triples C passes to the recursive calls)
+      // C: f3 = gts_face_new(en, e5, e2), f4 = gts_face_new(en, e3, e4).
+      // The stored ring starts at C's t->e1 (en) because gts_triangle_vertices
+      // reads (e1-only, e1∩e2, e2-only): f3 → (v3, v4, v2), f4 → (v4, v3, v1).
+      // That is the vertex order mkSurface emits and triCenter sums in.
       this.removeFace(f1);
       this.removeFace(f2);
-      const f3 = this.addFace([v4, v2, v3], [e5, e2, en]);
-      const f4 = this.addFace([v1, v4, v3], [e4, en, e3]);
+      const f3 = this.addFace([v3, v4, v2], [en, e5, e2]);
+      const f4 = this.addFace([v4, v3, v1], [en, e3, e4]);
 
       this.swapIfInCircle(f3, v4, v2, v3, e5, e2, en);
       this.swapIfInCircle(f4, v1, v4, v3, e4, en, e3);

package/src/layout/neato/edge-len.ts

@@ -9,6 +9,7 @@
 
 import type { Graph } from '../../model/graph.js';
 import type { Edge } from '../../model/edge.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 /** `dfltlen` passed by scan_graph_mode. @see lib/neatogen/stuff.c:scan_graph_mode */
 export const DEFAULT_EDGE_LEN = 1.0;
@@ -24,7 +25,7 @@ export function lenattr(ep: Edge, g: Graph): number {
   const val = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(s);
   const len = val === null ? Number.NaN : parseFloat(val[0]);
   if (Number.isNaN(len) || len < 0 || len === 0) {
-    console.warn(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+    agerrLineOn('warn', `bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
     return DEFAULT_EDGE_LEN;
   }
   return len;

package/src/layout/neato/fdp-adjust.ts

@@ -26,6 +26,7 @@ import { vpscAdjust } from './vpsc-adjust.js';
 import { sepFactor } from './sep-factor.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import { RenderError } from '../../errors.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 /** @see lib/neatogen/adjust.c:DFLT_MARGIN (points) */
 const DFLT_MARGIN = 4;
@@ -161,7 +162,7 @@ export function warnUnrecognizedOverlap(flag: string | undefined): void {
   const s = flag.toLowerCase();
   if (s.startsWith('prism') || NAMED_MODES.has(s)) return;
   if (mapBoolDflt(flag, false) === mapBoolDflt(flag, true)) return;
-  console.warn(`Unrecognized overlap value "${flag}" - using false`);
+  agerrLineOn('warn', `Unrecognized overlap value "${flag}" - using false`);
 }
 
 /**
@@ -203,7 +204,7 @@ function adjustLate(g: Graph, am: AdjustData): number {
     case AM_IPSEP: return 0;
     case AM_VPSC: return vpscAdjust(g);
     default:
-      console.warn(`Unhandled adjust option ${am.print}`);
+      agerrLineOn('warn', `Unhandled adjust option ${am.print}`);
       return 0;
   }
 }

package/src/layout/neato/init.ts

@@ -50,6 +50,7 @@ export const MODE_HIER = 2;
 export const MODE_IPSEP = 3;
 /** Stochastic gradient descent. @see lib/neatogen/neatoprocs.h */
 export const MODE_SGD = 4;
+/** `MaxIter` under MODE_SGD. @see neatoinit.c:1285 */ const SGD_ITERATIONS = 30;
 
 // ---------------------------------------------------------------------------
 // Model constants — @see lib/neatogen/defs.h
@@ -321,6 +322,13 @@ export function mapModelToStress(model: number): number {
 // solveModel helpers
 // ---------------------------------------------------------------------------
 
+/** `MaxIter` per mode; `maxiter` goes through C `atoi` (no digits -> 0). @see neatoinit.c:1280-1287 */
+export function neatoMaxIter(maxiter: string | undefined, mode: number, n: number): number {
+  if (maxiter !== undefined) return parseInt(maxiter, 10) || 0;
+  if (mode === MODE_MAJOR) return DFLT_ITERATIONS;
+  return mode === MODE_SGD ? SGD_ITERATIONS : 100 * n;
+}
+
 /** 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
@@ -329,7 +337,7 @@ export function runMajorization(g: Graph, mode: number, model: number): void {
   const haveLen = graphHasLen(g);
   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 maxi = neatoMaxIter(g.attrs.get('maxiter'), mode, n);
   const epsilon = lateDouble(g.attrs.get('epsilon'), 1e-4, 0); // DFLT_TOLERANCE
   // 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).
@@ -389,11 +397,7 @@ export function makeGraphDataC(
   return vtx;
 }
 
-/**
- * Dispatch to the appropriate layout solver for the given mode.
- *
- * @see lib/neatogen/neatoinit.c:neatoLayout
- */
+/** Dispatch to the layout solver for the mode. @see lib/neatogen/neatoinit.c:neatoLayout */
 export function solveModel(g: Graph, mode: number, model: number): void {
   if (g.nodes.size < 2) return;
   assertSupported(g, mode, model);
@@ -411,11 +415,7 @@ export function solveModel(g: Graph, mode: number, model: number): void {
 // neatoTranslate helpers
 // ---------------------------------------------------------------------------
 
-/**
- * Find minimum X and Y across all node positions.
- *
- * @see lib/neatogen/neatoinit.c (translate logic)
- */
+/** Minimum X and Y across all node positions. @see lib/neatogen/neatoinit.c (translate logic) */
 export function findMinPos(g: Graph): { minX: number; minY: number } {
   let minX = Infinity;
   let minY = Infinity;

package/src/layout/neato/kk.ts

@@ -27,6 +27,7 @@ import { MODEL_MDS } from './init.js';
 import { solve } from './kk-solve.js';
 import { lenattr } from './edge-len.js';
 import { newPathState, shortestPath, mdsModel, type Neighbour } from './kk-paths.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 /** `Ndim`: layout dimension (this port lays out in 2-D only). */
 const NDIM = 2;
@@ -289,7 +290,7 @@ function moveNode(st: KkState, m: number): void {
 function solveModel(g: Graph, st: KkState): void {
   for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
   if (st.move === st.maxIter) {
-    console.warn(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agerrLineOn('warn', `Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
   }
 }
 

package/src/layout/neato/multispline-router.ts

@@ -19,6 +19,7 @@
 import type { Point, Poly } from '../../pathplan/types.js';
 import { wind } from '../../pathplan/visibility.js';
 import { mkSurface } from './cdt-surface.js';
+import { dist2 } from '../../common/spline-midpoint.js';
 import { InternalError } from '../../errors.js';
 
 /** index pair. @see multispline.c:ipair */
@@ -87,9 +88,8 @@ function sharedEdge(faces: number[], p3: number, q3: number): Ipair {
 
 /** @see multispline.c:addTriEdge */
 export function addTriEdge(g: Tgraph, t: number, h: number, seg: Ipair): void {
-  const dist = Math.hypot(
-    g.nodes[t]!.ctr.x - g.nodes[h]!.ctr.x,
-    g.nodes[t]!.ctr.y - g.nodes[h]!.ctr.y);
+  /* DIST = sqrt(fused DIST2): libgvplugin_neato_layout _addTriEdge fmul/fmadd/fsqrt */
+  const dist = Math.sqrt(dist2(g.nodes[t]!.ctr, g.nodes[h]!.ctr));
   const idx = g.edges.length;
   g.edges.push({ t, h, seg, dist });
   g.nodes[t]!.edges.push(idx);

package/src/layout/neato/multispline.ts

@@ -25,6 +25,7 @@ import { clipAndInstall } from '../../common/splines-clip.js';
 import { makeStraightEdges, addEdgeLabels } from '../dot/straight-edges.js';
 import type { Router, Ipair } from './multispline-router.js';
 import { addEndpoint, edgeToSeg, triPath } from './multispline-router.js';
+import { agwarningf } from '../../common/agerr.js';
 
 export type { Router } from './multispline-router.js';
 export { mkRouter } from './multispline-router.js';
@@ -339,8 +340,8 @@ function chainOf(e: Edge): Edge[] {
  * @see multispline.c:genroute
  */
 function warnNoControlPoints(e: Edge): number {
-  console.warn(
-    `Warning: Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
+  agwarningf(
+    `Could not create control points for multiple spline for edge (${e.tail.name},${e.head.name})`,
   );
   return 1;
 }

package/src/layout/neato/poly.ts

@@ -19,6 +19,7 @@ import type { Node } from '../../model/node.js';
 import type { Box, Point } from '../../model/geom.js';
 import { ShapeKind } from '../../common/types.js';
 import type { PolygonT } from '../../common/types.js';
+import { agerrorf } from '../../common/agerr.js';
 
 /** @see lib/neatogen/poly.c:BOX */
 export const POLY_BOX = 1;
@@ -258,7 +259,7 @@ export function makeAddPoly(n: Node, xmargin: number, ymargin: number): Poly | n
     case ShapeKind.SH_POINT:
       return finishPoly(genRound(n, xmargin, ymargin), POLY_CIRCLE);
     default:
-      console.error(`Error: makeAddPoly: unknown shape type ${shapeName(n)}\n`);
+      agerrorf(`makeAddPoly: unknown shape type ${shapeName(n)}\n`);
       return null;
   }
 }
@@ -296,7 +297,7 @@ function baseShape(n: Node): { verts: Point[]; kind: number } | null {
     case ShapeKind.SH_POINT:
       return { verts: genRound(n, 0, 0), kind: POLY_CIRCLE };
     default:
-      console.error(`Error: makePoly: unknown shape type ${shapeName(n)}\n`);
+      agerrorf(`makePoly: unknown shape type ${shapeName(n)}\n`);
       return null;
   }
 }

package/src/layout/neato/sgd.ts

@@ -17,6 +17,7 @@ import type { RkState } from '../../util/mt19937.js';
 import { drand48 } from '../../common/random.js';
 import { lateDouble } from '../../common/nodeinit.js';
 import { checkStart, parseStart, INIT_RANDOM, INIT_REGULAR } from './start.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 // ---------------------------------------------------------------------------
 // Model constants — @see lib/neatogen/defs.h
@@ -407,13 +408,15 @@ export function buildUnfixed(g: Graph, n: number): boolean[] {
  */
 export function resolveModel(model: number): number {
   if (model === MODEL_CIRCUIT) {
-    console.warn(
+    agerrLineOn(
+      'warn',
       'circuit model not yet supported in Gmode=sgd, reverting to shortpath model',
     );
     return MODEL_SHORTPATH;
   }
   if (model === MODEL_MDS) {
-    console.warn(
+    agerrLineOn(
+      'warn',
       'mds model not yet supported in Gmode=sgd, reverting to shortpath model',
     );
     return MODEL_SHORTPATH;