@knowvah/dot-engine 2.6.11 → 2.6.12

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;

package/src/layout/neato/start.ts

@@ -13,12 +13,14 @@
 import { RenderError } from '../../errors.js';
 import type { Graph } from '../../model/graph.js';
 import { srand48 } from '../../common/random.js';
+import { registerRenderState } from '../../common/render-state.js';
 import { mapbool, isACluster } from '../dot/rank.js';
 import { getPack } from '../pack/index.js';
 import {
   MODE_KK, MODE_MAJOR, MODE_HIER, MODE_IPSEP, MODE_SGD,
   MODEL_CIRCUIT, MODEL_SUBSET,
 } from './init.js';
+import { agerrLineOn } from '../../common/agerr.js';
 
 /** @see lib/neatogen/neato.h:INIT_SELF */
 export const INIT_SELF = 0;
@@ -41,11 +43,12 @@ const WARN_POS_IGNORED = 'node positions are ignored unless start=random';
 const WARN_SELF_IGNORED = 'start=0 not supported with mode=self - ignored';
 
 /**
- * Roots already warned about start=self under KK/SGD. C warns once per process
- * (stuff.c:330 static atomic_flag); one render is one C process here, so the
- * flag is per root graph rather than module state (multi-diagram safety).
+ * C's `static atomic_flag once` for the start=self warning under KK/SGD: once
+ * per process, so once per render here (AD-4 resets it at render entry).
+ * @see lib/neatogen/stuff.c:330
  */
-const selfWarned = new WeakSet<object>();
+const selfOnce = { warned: false };
+registerRenderState(() => { selfOnce.warned = false; });
 /** Roots already warned about the KK circuit fallback (one warning per graph). */
 const circuitWarned = new WeakSet<object>();
 
@@ -96,7 +99,7 @@ export function checkStart(
 ): number {
   const { init, seed } = parseStart(g.root.attrs.get('start'), dflt);
   if (init !== INIT_RANDOM && [...g.nodes.values()].some((n) => n.attrs.has('pos'))) {
-    console.warn(WARN_POS_IGNORED);
+    agerrLineOn('warn', WARN_POS_IGNORED);
   }
   if (init === INIT_REGULAR) initRegular(g, nG);
   srand48(seed);
@@ -141,7 +144,7 @@ export function neatoMode(g: Graph): number {
   if (str === undefined || str === '') return MODE_MAJOR;
   const mode = modeByName().get(str);
   if (mode !== undefined) return mode;
-  console.warn(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  agerrLineOn('warn', `Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
   return MODE_MAJOR;
 }
 
@@ -161,9 +164,9 @@ function checkStartAttr(g: Graph, mode: number): void {
   // @see lib/neatogen/neatoinit.c:1095, lib/neatogen/stress.c:884 (smart_ini)
   if (mode === MODE_MAJOR || mode === MODE_IPSEP) unsupported('start', value ?? '', 'smart initialisation');
   // @see lib/neatogen/stuff.c:330 (KK and SGD warn once and ignore it)
-  if ((mode === MODE_KK || mode === MODE_SGD) && !selfWarned.has(g.root)) {
-    selfWarned.add(g.root);
-    console.warn(WARN_SELF_IGNORED);
+  if ((mode === MODE_KK || mode === MODE_SGD) && !selfOnce.warned) {
+    selfOnce.warned = true;
+    agerrLineOn('warn', WARN_SELF_IGNORED);
   }
 }
 
@@ -189,7 +192,8 @@ function kkCircuitFallsBack(g: Graph): boolean {
 function warnCircuitDisconnected(g: Graph): void {
   if (circuitWarned.has(g.root)) return;
   circuitWarned.add(g.root);
-  console.warn(
+  agerrLineOn(
+    'warn',
     `graph ${g.root.name} is disconnected. Hence, the circuit model\n`
     + 'is undefined. Reverting to the shortest path model.\n'
     + 'Alternatively, consider running neato using -Gpack=true or decomposing\n'

package/src/ortho/index.ts

@@ -20,6 +20,7 @@ import {
 } from "./sgraph.js";
 import { convertSPtoRoute, assignSegs, assignTracks, vtrack, htrack } from "./ortho-route.js";
 import { gvQsort } from "../util/bsd-qsort.js";
+import { agerrLineOn } from '../common/agerr.js';
 
 export type { OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint, ClipAndInstallFn };
 export { SEED } from "./partition.js";
@@ -144,7 +145,8 @@ export function orthoEdges(
   clipAndInstall?: ClipAndInstallFn,
 ): number {
   if (useLbls) {
-    console.warn(
+    agerrLineOn(
+      'warn',
       "Orthogonal edges do not currently handle edge labels. Try using xlabels.\n",
     );
     useLbls = false; // eslint-disable-line no-param-reassign

package/src/parser/dot.js

@@ -3,6 +3,9 @@
 // https://peggyjs.org/
 
 
+
+  import { agwarningf } from "../common/agerr.js";
+
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -286,7 +289,7 @@ function peg$parse(input, options) {
   function peg$f13(t, m, attrs) {
     // 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");
+    if (m) agwarningf("attribute macros not implemented", "error");
     return { type: "attr", target: t, attrs: attrs };
   }
   function peg$f14(a) {    return { type: "assign", key: a.key, value: a.value };  }

package/src/parser/dot.pegjs

@@ -8,6 +8,10 @@
 // Architecture decision AD-11: this file is the canonical faithfulness
 // artifact; every production cites its Bison rule or Flex token.
 
+{{
+  import { agwarningf } from "../common/agerr.js";
+}}
+
 // ── Top-level rule ───────────────────────────────────────────────────────────
 // grammar.y: graph : hdr body | error | /* empty */
 // `end` is the offset just past the graph's closing brace: the last input the
@@ -71,7 +75,7 @@ AttrStmt
     {
       // 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");
+      if (m) agwarningf("attribute macros not implemented", "error");
       return { type: "attr", target: t, attrs: attrs };
     }
   / a:AttrAssignment

package/src/parser/index.ts

@@ -18,6 +18,7 @@ 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';
+import { agerrFinished } from '../common/agerr.js';
 
 // ── ParseError ────────────────────────────────────────────────────────────────
 
@@ -233,7 +234,7 @@ export function isPeggyError(err: unknown): err is {
 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));
+    agerrFinished(numberAmbiguityMessage(a), 'error');
   }
 }
 
@@ -250,7 +251,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));
+      agerrFinished(syntaxErrorMessage(src, start.offset));
       const code: GvErrorCode =
         err.found === null ? 'SYNTAX_UNEXPECTED_EOF' : 'SYNTAX_ERROR';
       throw new ParseError(
@@ -282,7 +283,7 @@ export function parse(src: string): Graph {
     const offset = err instanceof ParseError ? err.location.offset : undefined;
     if (offset !== undefined) {
       warnNumberAmbiguities(src, offset);
-      console.error(syntaxErrorMessage(src, offset));
+      agerrFinished(syntaxErrorMessage(src, offset));
     }
     throw err;
   }