@knowvah/dot-engine 2.6.11 → 2.6.12

package/src/common/poly-init.ts

@@ -24,6 +24,7 @@ import {
   DEFAULT_COLOR,
 } from './make-label.js';
 import { computeVertices } from './poly-vertices.js';
+import { agwarningf } from './agerr.js';
 
 // Default half-dimensions in points (72 dpi, 0.75 in wide, 0.5 in tall)
 const DEFAULT_LW = 27;
@@ -117,7 +118,7 @@ export function polyInit(n: Node, g: Graph, measurer: TextMeasurer): void {
   // C warns when the custom shape's image cannot be sized (headless: always).
   // @see lib/common/shapes.c:2027-2033
   if (shapefile !== undefined && shapefile !== '' && shapeName !== 'epsf') {
-    console.error(`Warning: No or improper shapefile="${shapefile}" for node "${n.name}"`);
+    agwarningf(`No or improper shapefile="${shapefile}" for node "${n.name}"`, 'error');
   }
   if ((n.info.shape as ShapeDesc).kind === ShapeKind.SH_RECORD) {
     if (n.info.shape_info === undefined) recordNodeInit(n, g, measurer);

package/src/common/postproc.ts

@@ -26,6 +26,8 @@ import {
   RANKDIR_TB, RANKDIR_LR, RANKDIR_BT, RANKDIR_RL,
 } from '../layout/dot/init.js';
 import { addXLabels } from './xlabels-place.js';
+import { registerRenderState } from './render-state.js';
+import { agerrLineOn } from './agerr.js';
 
 /** Concentrated multi-edge duplicate — never drawn. @see lib/common/const.h:IGNORED */
 const IGNORED_EDGE = 6;
@@ -38,6 +40,7 @@ const IGNORED_EDGE = 6;
 
 let Rankdir = 0;
 let Offset: Point = { x: 0, y: 0 };
+registerRenderState(() => { Rankdir = 0; Offset = { x: 0, y: 0 }; });
 
 /** The bezier fields map_edge reads/writes. */
 type MappedBezier = Pick<Bezier, 'list' | 'sflag' | 'eflag' | 'sp' | 'ep' | 'sArrowOps' | 'eArrowOps'>;
@@ -226,7 +229,7 @@ function translateDrawing(g: Graph): void {
       // @see lib/common/postproc.c:map_edge ("lost %s %s edge")
       if (e.info.spl === undefined) {
         if (!(g.info.concentrate ?? false) && (e.info.edge_type ?? 0) !== IGNORED_EDGE) {
-          console.warn(`lost ${e.tail.name} ${e.head.name} edge`);
+          agerrLineOn('warn', `lost ${e.tail.name} ${e.head.name} edge`);
         }
         continue;
       }

package/src/common/random.ts

@@ -14,12 +14,22 @@
  * @see lib/neatogen/neatoinit.c:checkStart (srand48 call)
  */
 
+import { registerRenderState } from './render-state.js';
+
 const A = BigInt('0x5deece66d');
 const C = BigInt('0xb');
 const MASK48 = (1n << 48n) - 1n;
 const TWO48 = 2 ** 48;
+/**
+ * Unseeded generator state: libc's X0 = 0x1234ABCD330E (rand48 seed words
+ * 0x1234, 0xABCD, 0x330E); verified on the reference machine — an unseeded
+ * drand48() returns 0.39646477376027534.
+ * @see POSIX drand48(3)
+ */
+const UNSEEDED_STATE = 0x1234abcd330en;
 
-let state = 0x330en; // POSIX default: X0 = 0x1234ABCD330E... see srand48 note
+let state = UNSEEDED_STATE;
+registerRenderState(() => { state = UNSEEDED_STATE; });
 
 /**
  * Seed the generator: X = (seed << 16) | 0x330E (low 32 bits of seed).

package/src/common/render-state.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Per-render scope for C process-level state (AD-4).
+ *
+ * Native Graphviz renders one graph per `dot` process, so every file static —
+ * RNG streams, sequence counters, the emit_once warning set — starts each
+ * graph at its C initial value (and gvFreeContext's emit_once_reset clears the
+ * warning set). The port's module statics outlive a render, so each module
+ * owning such state registers a reset that restores its C initial value, and
+ * every public render entry calls {@link resetRenderState} before any other
+ * work. Render output is then a function of its input alone.
+ *
+ * Not registered here: caller-installed hooks (setTextMeasurer,
+ * setImageSizer, setImageResolver) and debug hooks — they are configuration,
+ * not C process state.
+ *
+ * @see lib/gvc/gvcontext.c:gvFreeContext (emit_once_reset)
+ * @see lib/common/emit.c:emit_once_reset
+ */
+
+/** Registered resets, run in registration (module evaluation) order. */
+const resets: Array<() => void> = [];
+
+/**
+ * Register a reset restoring one module's C process state to its initial
+ * value. Called once, at module evaluation.
+ */
+export function registerRenderState(reset: () => void): void {
+  resets.push(reset);
+}
+
+/** Restore every registered module's C process state; call first per render. */
+export function resetRenderState(): void {
+  for (const reset of resets) reset();
+}

package/src/common/splines-geom.ts

@@ -10,6 +10,7 @@
 
 import type { Point, Box } from '../model/geom.js';
 import { bezier as evalBezier } from './bezier.js';
+import { fma } from './fma.js';
 
 // ---------------------------------------------------------------------------
 // Approximate equality
@@ -47,16 +48,19 @@ const HW = 2.0;
 const SMALL = 0.0000000001;
 
 /**
- * Distance from point p to line a-b, squared.
+ * Distance from point p to line a-b, squared. Native (arm64, clang
+ * -ffp-contract=on) fuses the numerator as fmadd(p.y-a.y, dx, -(dy*(p.x-a.x)))
+ * and the denominator as fmadd(dx, dx, dy*dy): libgvc _ptToLine2 at
+ * 0x21214-0x21244, identically in inlined _update_bb_bz and _approx_bezier.
  * @see lib/common/geom.c:ptToLine2
  */
-function ptToLine2(a: Point, b: Point, p: Point): number {
+export function ptToLine2(a: Point, b: Point, p: Point): number {
   const dx = b.x - a.x;
   const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
+  let a2 = fma(p.y - a.y, dx, -(dy * (p.x - a.x)));
   a2 *= a2; // square — ensures positive
   if (a2 < SMALL) return 0; // avoid 0/0 problems
-  return a2 / (dx * dx + dy * dy);
+  return a2 / fma(dx, dx, dy * dy);
 }
 
 /**

package/src/common/splines-routespl.ts

@@ -15,6 +15,7 @@ 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';
+import { agerrLineOn } from './agerr.js';
 
 // ---------------------------------------------------------------------------
 // Stage-dump hook (diagnosis only; null in production — same pattern as
@@ -450,7 +451,7 @@ function routeSplinesInternal(pp: Path, polyline: boolean): Point[] | null {
   if (pl === null) {
     // C: agerrorf("in routesplines, Pshortestpath failed") — the caller then
     // loses the edge. @see lib/common/routespl.c (Pshortestpath < 0 branch)
-    console.warn('in routesplines, Pshortestpath failed');
+    agerrLineOn('warn', 'in routesplines, Pshortestpath failed');
     return null;
   }
   emitDump('S3_POLY', dumpNames, () => ({

package/src/common/textmeasure-lookup.ts

@@ -8,6 +8,8 @@ import {
   ALL_FONT_METRICS,
   type FontFamilyData,
 } from "./textmeasure-lut-data.js";
+import { registerRenderState } from "./render-state.js";
+import { agwarningf } from './agerr.js';
 
 /** Times is always present; used as the fallback family. */
 export const TIMES_FALLBACK: FontFamilyData = ALL_FONT_METRICS[0]!;
@@ -30,8 +32,13 @@ export function normalizeFontName(name: string): string {
   return result;
 }
 
-/** Set of font names that have already triggered the fallback warning. */
+/**
+ * Font names that have already triggered the fallback warning: C's emit_once
+ * set, emptied per render (a native run is one process; emit_once_reset).
+ * @see lib/common/emit.c:emit_once
+ */
 const warnedFontNames = new Set<string>();
+registerRenderState(() => warnedFontNames.clear());
 
 /** @see lib/common/textspan_lut.c:get_metrics_for_font_family */
 export function getFamilyMetrics(fontName: string): FontFamilyData {
@@ -41,8 +48,8 @@ export function getFamilyMetrics(fontName: string): FontFamilyData {
   }
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
-    console.warn(
-      `Warning: no hard-coded metrics for '${fontName}'.  ` +
+    agwarningf(
+      `no hard-coded metrics for '${fontName}'.  ` +
         `Falling back to 'Times' metrics`,
     );
   }

package/src/common/textmeasure.ts

@@ -10,6 +10,8 @@
 import { type FontFamilyData } from "./textmeasure-lut-data.js";
 import { getFamilyMetrics, normalizeFontName } from "./textmeasure-lookup.js";
 import { canvasFont } from "./css-font.js";
+import { agwarningf } from "./agerr.js";
+import { registerRenderState } from "./render-state.js";
 
 /** Number of hard-coded font families in the LUT. */
 export const LUT_FAMILY_COUNT = 11;
@@ -72,12 +74,53 @@ function getVariantWidths(
 // ── Character width lookup ────────────────────────────────────────────────────
 
 const SPACE_CHAR_CODE = 32;
+const FIRST_NON_ASCII = 128;
+
+/**
+ * C's two `static bool warning_already_reported` flags, one per warning.
+ * Once per render (AD-4), as one native process renders one graph.
+ * @see lib/common/textspan_lut.c:estimate_character_width_canonical
+ */
+const warned = new Set<string>();
+const NON_ASCII_FLAG = "non-ascii";
+const ASCII_FLAG = "ascii";
+
+registerRenderState(() => warned.clear());
+
+/**
+ * The C format strings already begin with `Warning: `, and agwarningf adds its
+ * own prefix, so native prints `Warning: Warning: ...`. The trailing newline
+ * of the C format is the line terminator `console.warn` supplies.
+ */
+function warnNonAscii(character: number): void {
+  if (warned.has(NON_ASCII_FLAG)) return;
+  warned.add(NON_ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of non-ASCII character ${character}. Falling back to width of space character`,
+  );
+}
+
+function warnAscii(character: number): void {
+  if (warned.has(ASCII_FLAG)) return;
+  warned.add(ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of ASCII character ${character}. Falling back to 0`,
+  );
+}
 
 /** @see lib/common/textspan_lut.c:estimate_character_width_canonical */
 function charWidthUnits(widths: readonly number[], charCode: number): number {
-  const code = charCode >= 128 ? SPACE_CHAR_CODE : charCode;
+  let code = charCode;
+  if (code >= FIRST_NON_ASCII) {
+    warnNonAscii(code);
+    code = SPACE_CHAR_CODE;
+  }
   const w = widths[code] ?? -1;
-  return w < 0 ? 0 : w;
+  if (w < 0) {
+    warnAscii(code);
+    return 0;
+  }
+  return w;
 }
 
 /**

package/src/gvc/anchor.ts

@@ -21,6 +21,7 @@ import { substObjAnchor, preprocessTooltip } 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 { ptToLine2 } from '../common/splines-geom.js';
 import type { RendererPlugin } from './context.js';
 import { MapShape, type ObjState, type RenderJob } from './job.js';
 
@@ -231,8 +232,6 @@ export function beginAnchorIf(renderer: RendererPlugin, job: RenderJob): boolean
 const DFLT_SAMPLE = 20;
 /** HW: maximum distance from line, in points. @see lib/common/emit.c:739 */
 const MAP_HW = 2.0;
-/** SMALL: 0/0 guard in ptToLine2. @see lib/common/geom.c:176 */
-const MAP_SMALL = 0.0000000001;
 
 /**
  * Coordinate-transform context for the imagemap device. `bb` is the unpadded
@@ -430,16 +429,6 @@ export function computeLabelRectMap(lab: TextlabelT, obj: ObjState, ctx: MapCtx)
 
 // --- Edge spline hot spots (map_output_bspline) --------------------------
 
-/** ptToLine2: squared distance from p to segment (a,b). @see lib/common/geom.c */
-function ptToLine2(a: Point, b: Point, p: Point): number {
-  const dx = b.x - a.x;
-  const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
-  a2 *= a2;
-  if (a2 < MAP_SMALL) return 0;
-  return a2 / (dx * dx + dy * dy);
-}
-
 /** check_control_points: both handles within HW of the chord. @see emit.c */
 function checkControlPoints(cp: Point[]): boolean {
   return ptToLine2(cp[0]!, cp[3]!, cp[1]!) < MAP_HW * MAP_HW

package/src/gvc/device-cluster.ts

@@ -13,7 +13,8 @@ import {
   parseStyleFlags, resolvePenColor, resolvePenType, resolvePenWidth,
   resolveClusterFillEx,
 } from '../common/style-resolve.js';
-import { resolveRenderColor, withColorScheme } from '../render/color-resolve.js';
+import { resolveRenderColor, withColorScheme, reportColorNames } from '../render/color-resolve.js';
+import { parseSegs } from '../common/multicolor.js';
 
 /**
  * Copy gradient fields from a linear/radial ResolvedFill onto obj.
@@ -101,14 +102,41 @@ export function applyClusterObjState(sg: Graph, job: RenderJob): boolean {
   const obj = job.obj;
   // C wraps the cluster color block with setColorScheme. @see emit.c:3800/3943
   return withColorScheme(clusterAttr(sg, 'colorscheme'), () => {
+    // C resolves the fill (set_fillcolor / gradient vals) before the pen,
+    // which is set just before gvrender_box. @see emit.c:3846-3868 vs 3907-3913
+    const filled = applyClusterFill(obj, fillRes);
     applyClusterPenState(obj, sg);
-    if (fillRes.kind === 'none') { obj.fill = FillType.None; return false; }
-    if (fillRes.kind === 'solid') {
-      obj.fill = FillType.Solid;
-      obj.fillColor = resolveRenderColor(fillRes.color);
-      return true;
-    }
-    applyClusterGradient(obj, fillRes);
-    return true;
+    reportColorNames(stripedClusterColors(sg));
+    return filled;
   });
 }
+
+/**
+ * The colours stripedBox sets for a `style=striped` cluster (not rounded): each
+ * segment of the fill spec with a positive width, after the pen.
+ * @see lib/common/emit.c:3896-3906 emit_clusters (striped branch)
+ * @see lib/common/emit.c:595 stripedBox
+ */
+function stripedClusterColors(sg: Graph): string[] {
+  const flags = parseStyleFlags(clusterStyle(sg));
+  if (!flags.striped || flags.rounded) return [];
+  const color = clusterAttr(sg, 'color') ?? '';
+  let fill = clusterAttr(sg, 'fillcolor') || color;
+  const bg = clusterAttr(sg, 'bgcolor') ?? '';
+  if ((!flags.filled || fill === '') && bg !== '') fill = bg;
+  const { segs, error } = parseSegs(fill === '' ? 'lightgrey' : fill);
+  if (error === 1 || error === 2) return [];
+  return segs.flatMap((seg) => (seg.color !== null && seg.t > 0 ? [seg.color] : []));
+}
+
+/** The fill half of {@link applyClusterObjState}; true when the box is filled. */
+function applyClusterFill(obj: ObjState, fillRes: ResolvedFill): boolean {
+  if (fillRes.kind === 'none') { obj.fill = FillType.None; return false; }
+  if (fillRes.kind === 'solid') {
+    obj.fill = FillType.Solid;
+    obj.fillColor = resolveRenderColor(fillRes.color);
+    return true;
+  }
+  applyClusterGradient(obj, fillRes);
+  return true;
+}

package/src/gvc/device-labels.ts

@@ -10,6 +10,7 @@
 
 import type { Graph } from '../model/graph.js';
 import type { Node } from '../model/node.js';
+import type { Edge } from '../model/edge.js';
 import type { RendererPlugin } from './context.js';
 import type { RenderJob } from './job.js';
 import type { TextlabelT } from '../common/types.js';
@@ -17,6 +18,8 @@ import type { TextSpan } from '../common/emit-types.js';
 import type { PlacedHtml } from '../common/htmltable-pos.js';
 import { gvrenderTextspan, withLabelEmitState } from './textspan-emit.js';
 import { emitHtmlLabel } from '../common/htmltable-emit.js';
+import { reportColorNames } from '../render/color-resolve.js';
+import { htmlLabelColors } from '../common/htmltable-emit-fill.js';
 
 /** valign codes stored on textlabel_t. @see lib/common/types.h:textlabel_t.valign */
 const VALIGN_TOP = 't'.charCodeAt(0);
@@ -38,6 +41,29 @@ function labelSpanX(lp: TextlabelT, just: 'l' | 'n' | 'r'): number {
   return lp.pos.x;
 }
 
+/**
+ * The names emit_label hands to gvrender_resolve_color: an HTML label's walk,
+ * or a plain label's fontcolor (set once, before the spans, when there is a
+ * span).
+ * @see lib/common/labels.c:emit_label
+ */
+export function labelColorNames(lp: TextlabelT): string[] {
+  if (lp.html) return lp.u.kind === 'html' ? htmlLabelColors(lp.u.html as PlacedHtml) : [];
+  return lp.u.kind === 'txt' && lp.u.nspans >= 1 ? [lp.fontcolor] : [];
+}
+
+/**
+ * Report the unknown colours of an edge's four labels in emit_end_edge order
+ * (label, xlabel, head, tail), each only when placed.
+ * @see lib/common/emit.c:emit_edge_label
+ */
+export function reportEdgeLabelColors(e: Edge): void {
+  const labels = [e.info.label, e.info.xlabel, e.info.head_label, e.info.tail_label];
+  for (const lp of labels as Array<TextlabelT | undefined>) {
+    if (lp?.set) reportColorNames(labelColorNames(lp));
+  }
+}
+
 /**
  * Emit one label's text spans if present and placed.
  * Shared by edge-label, node-xlabel, and graph-label slots.
@@ -59,6 +85,7 @@ export function renderOneLabel(
   // default pos. Callers mirroring the existence-only sites pass false.
   if (!lp) return;
   if (requireSet && !lp.set) return;
+  reportColorNames(labelColorNames(lp));
   // HTML branch: @see lib/common/labels.c:emit_label (226-230)
   // C routes to emit_html_label(job, lp->u.html, lp) using lp->pos as anchor.
   if (lp.html) {

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]!];
 }