@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/common/poly-gencode.ts

@@ -22,6 +22,7 @@ import { FillType } from '../gvc/context.js';
 import { emitHtmlLabel } from './htmltable-emit.js';
 import { transformPoint } from '../gvc/device.js';
 import { nodeAttr } from './poly-init.js';
+import { gvrenderSetStyle, checkStyleTokens } from '../gvc/gvrender-set-style.js';
 import { substObjAnchor, preprocessTooltip } from './subst.js';
 import type { ResolvedFill, PolyStyleFlags } from './style-resolve.js';
 import {
@@ -33,7 +34,8 @@ import {
   styleTokens,
 } from './style-resolve.js';
 import { stripedBox, wedgedEllipse } from '../render/svg-multicolor.js';
-import { resolveRenderColor } from '../render/color-resolve.js';
+import { resolveRenderColor, reportColorNames } from '../render/color-resolve.js';
+import { htmlLabelColors } from './htmltable-emit-fill.js';
 import { svgNodeId } from '../render/svg-id.js';
 import { drawRoundCorners, mcircleHack, underlineDraw } from './poly-shapes.js';
 
@@ -95,6 +97,7 @@ interface RingCtx {
   job: RenderJob;
   style: PolyStyleFlags;
   fillcolor: string;
+  nodeName: string; // agnameof(n): the `in node %s` AGPREV of a parseSegs rv > 1
   shape: number;
   diagonals: boolean;
   rounded: boolean;
@@ -113,7 +116,7 @@ function renderEllipseRing(
     const pf = ring.map(
       (v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job),
     );
-    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer);
+    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer, () => `in node ${ctx.nodeName}`);
     renderEllipse(ring, coord, ctx.renderer, ctx.job, false); // boundary unfilled
   } else {
     renderEllipse(ring, coord, ctx.renderer, ctx.job, filled);
@@ -123,14 +126,12 @@ function renderEllipseRing(
 }
 
 /**
- * Render one polygon periphery ring, dispatching to stripedBox when
- * style.striped + j==0.
+ * Striped j===0 ring: the multicolor box plus an unfilled boundary polygon.
  * @see lib/common/shapes.c:poly_gencode :3037-3043
  */
-/** Striped j===0 ring: the multicolor box plus an unfilled boundary polygon. */
 function renderStripedRing(ring: Point[], coord: Point, ctx: RingCtx): void {
   const af = ring.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
-  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer);
+  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer, () => `in node ${ctx.nodeName}`);
   renderPolygon(ring, coord, ctx.renderer, ctx.job, false); // boundary unfilled
 }
 
@@ -191,6 +192,8 @@ export function renderLabel(
   job: RenderJob,
 ): void {
   if (label.u.kind !== 'txt' || label.u.nspans < 1) return;
+  // gvrender_set_pencolor(job, lp->fontcolor), once, before the spans.
+  reportColorNames([label.fontcolor]);
   label.pos = coord;
   label.set = true;
   // First-span baseline per valign (labelloc). @see lib/common/labels.c:240-251
@@ -227,6 +230,7 @@ function renderNodeLabel(
     // Route the HTML label's box/fill/text ops into the node LABEL emit-state
     // (→ _ldraw_ for xdot), not the node DRAW state. SVG ignores emit_state.
     const html = label.u.html as PlacedHtml;
+    reportColorNames(htmlLabelColors(html));
     withLabelEmitState(job, () => emitHtmlLabel(html, coord, renderer, job));
   } else {
     renderLabel(label, coord, renderer, job);
@@ -363,12 +367,27 @@ function applyPenState(obj: ObjState, styleAttr: string | undefined,
 export function applyNodeStyle(obj: ObjState, n: Node, job: RenderJob): boolean {
   const styleAttr = nodeAttr(n, n.root, 'style');
   const colorAttr = nodeAttr(n, n.root, 'color');
+  // stylenode: gvrender_set_style(job, checkStyle list), before any colour is
+  // resolved; point_gencode passes its own fixed list instead (never unknown).
+  // @see lib/common/shapes.c:536 stylenode · :3257 point_gencode
+  if (!isPointNode(n)) {
+    const shape = n.info.shape as ShapeDesc | undefined;
+    gvrenderSetStyle(checkStyleTokens(styleTokens(styleAttr), shape?.polygon ?? null));
+  }
   // The node's `colorscheme` window is NOT opened here: C opens it once around
   // the whole node emission (emit_begin_node..emit_end_node), which covers both
   // this color block and the label textspans. Both callers of this function are
   // codefns, so they already run inside that window. @see gvc/device.ts
+  const penwidth = nodeAttr(n, n.root, 'penwidth');
+  // record_gencode resolves the pen (penColor) before the fill; poly_gencode
+  // and point_gencode resolve the fill first. Only the order in which an
+  // unknown colour is reported differs. @see shapes.c:3890-3892 vs 2985-3004
+  if ((n.info.shape as ShapeDesc | undefined)?.kind === ShapeKind.SH_RECORD) {
+    applyPenState(obj, styleAttr, colorAttr, penwidth);
+    return applyFillState(obj, n, job);
+  }
   const filled = applyFillState(obj, n, job);
-  applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, 'penwidth'));
+  applyPenState(obj, styleAttr, colorAttr, penwidth);
   return filled;
 }
 
@@ -379,7 +398,8 @@ export function applyNodeStyle(obj: ObjState, n: Node, job: RenderJob): boolean
  */
 function prepareDrawPoly(poly: PolygonT, filled: boolean, obj: ObjState): PolygonT {
   if (poly.peripheries !== 0 || !filled) return poly;
-  obj.penColor = { type: 'string', s: 'transparent' };
+  // gvrender_set_pencolor resolves (and may report) the name like any other.
+  obj.penColor = resolveRenderColor('transparent');
   return { ...poly, peripheries: 1 };
 }
 
@@ -434,6 +454,7 @@ function resolveNodeDrawCtx(job: RenderJob, n: Node): NodeDrawCtx | null {
     job,
     style: styleFlags,
     fillcolor: nodeAttr(n, n.root, 'fillcolor') ?? '',
+    nodeName: n.name,
     ...specialCornerFlags(drawPoly.option, styleFlags),
   };
   return { poly: drawPoly, coord, filled, ringCtx };
@@ -455,8 +476,7 @@ function specialCornerFlags(
 }
 
 /**
- * Render node shape (polygon/ellipse) and label.
- * Shape codefn — called from walkNodes.
+ * Render node shape (polygon/ellipse) and label; shape codefn, from walkNodes.
  * @see lib/common/shapes.c:poly_gencode
  */
 export function polyGencode(rawJob: unknown, rawNode: unknown): void {

package/src/common/poly-init.ts

@@ -24,6 +24,8 @@ import {
   DEFAULT_COLOR,
 } from './make-label.js';
 import { computeVertices } from './poly-vertices.js';
+import { agwarningf } from './agerr.js';
+import { imageIsSupplied, imageOpenWarning } from '../gvc/usershape.js';
 
 // Default half-dimensions in points (72 dpi, 0.75 in wide, 0.5 in tall)
 const DEFAULT_LW = 27;
@@ -110,6 +112,22 @@ export function buildNodeLabel(n: Node, g: Graph, measurer: TextMeasurer): void
   n.info.label = makeAnyLabel(content, isHtml, font, measurer, n);
 }
 
+/**
+ * poly_init's `image` branch (a non-custom shape): when the caller supplies no
+ * image, gvusershape_size fails and C warns after gvusershape_open's own
+ * warning. The port never sizes node images.
+ * @see lib/common/shapes.c:2043-2046
+ */
+function warnMissingImage(n: Node, g: Graph, shapefile: string | undefined): void {
+  if (shapefile !== undefined && shapefile !== '' && nodeAttr(n, g, 'shape') !== 'epsf') return;
+  const image = nodeAttr(n, g, 'image');
+  if (image === undefined || image === '') return;
+  const gvc = g.root.info.gvc;
+  if (imageIsSupplied(image, gvc?.imageSizer, gvc?.imageResolver)) return;
+  agwarningf(imageOpenWarning(image));
+  agwarningf(`No or improper image="${image}" for node "${n.name}"`);
+}
+
 export function polyInit(n: Node, g: Graph, measurer: TextMeasurer): void {
   const shapeName = nodeAttr(n, g, 'shape') ?? 'ellipse';
   const shapefile = nodeAttr(n, g, 'shapefile');
@@ -117,12 +135,13 @@ 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}"`);
   }
   if ((n.info.shape as ShapeDesc).kind === ShapeKind.SH_RECORD) {
     if (n.info.shape_info === undefined) recordNodeInit(n, g, measurer);
     return;
   }
+  warnMissingImage(n, g, shapefile);
   buildNodeLabel(n, g, measurer);
 
   // Layout-time common_init_node already installed the attr-resolved

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 { agerrorf } 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`);
+          agerrorf(`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-clip.ts

@@ -16,7 +16,7 @@ import type { Edge } from '../model/edge.js';
 import type { Node } from '../model/node.js';
 import { approxEqPt, bezierClip, updateBbBz, InsideContext } from './splines-geom.js';
 import { MILLIPOINT, ARR_NONE } from './splines-constants.js';
-import { arrowClipLength } from '../layout/dot/edge-route-clip.js';
+import { arrowClipLength, distFused } from '../layout/dot/edge-route-clip.js';
 import {
   arrowDrawOpsForEnd, edgeArrowName, edgeArrowsize,
 } from '../layout/dot/edge-route-arrow.js';
@@ -25,6 +25,14 @@ import { resolvePenWidth, parseStyleFlags } from './style-resolve.js';
 /** Normal (filled triangle) arrowhead. @see lib/common/const.h:ARR_TYPE_NORM */
 export const ARR_NORM = 1;
 
+/**
+ * DIST(p, q) as the oracle compiles it: sqrt(fma(dx, dx, dy * dy)), not
+ * Math.hypot (libgvc 16.1 `_arrowEndClip`/`_arrowStartClip`, incl. the inlined
+ * sphere_ctx inside(), and `_arrowOrthoClip`).
+ * @see lib/common/geom.h:DIST
+ */
+export const dist: (p: Point, q: Point) => number = distFused;
+
 // Internal shape accessor type for host objects that may carry a shape.
 type ShapeHost = { shape?: { fns?: { insidefn?: ((c: InsideContext, p: Point) => boolean) | null } | null } | null };
 
@@ -123,11 +131,6 @@ class SplineClipHelper {
     return [sflag, eflag];
   }
 
-  /** DIST(p, q). */
-  static dist(p: Point, q: Point): number {
-    return Math.hypot(p.x - q.x, p.y - q.y);
-  }
-
   /** Sphere inside-fn around `tip` with radius `r` for bezierClip. */
   static sphereCtx(tip: Point, r: number): {
     ctx: InsideContext;
@@ -135,7 +138,7 @@ class SplineClipHelper {
   } {
     return {
       ctx: { nodeCoord: { x: 0, y: 0 }, rw: 0, bp: null },
-      fn: (_c: InsideContext, p: Point) => SplineClipHelper.dist(p, tip) <= r,
+      fn: (_c: InsideContext, p: Point) => dist(p, tip) <= r,
     };
   }
 
@@ -170,7 +173,7 @@ class SplineClipHelper {
       SplineClipHelper.clipArrowsize(e), SplineClipHelper.clipPenwidth(e));
     spl.eflag = eflag;
     spl.ep = ps[endp + 3]!;
-    if (endp > startp && SplineClipHelper.dist(ps[endp]!, ps[endp + 3]!) < elen) {
+    if (endp > startp && dist(ps[endp]!, ps[endp + 3]!) < elen) {
       endp -= 3;
     }
     const sp: Point[] = [spl.ep, ps[endp + 2]!, ps[endp + 1]!, ps[endp]!];
@@ -198,7 +201,7 @@ class SplineClipHelper {
       SplineClipHelper.clipArrowsize(e), SplineClipHelper.clipPenwidth(e));
     spl.sflag = sflag;
     spl.sp = ps[startp]!;
-    if (endp > startp && SplineClipHelper.dist(ps[startp]!, ps[startp + 3]!) < slen) {
+    if (endp > startp && dist(ps[startp]!, ps[startp + 3]!) < slen) {
       startp += 3;
     }
     const sp: Point[] = [ps[startp + 3]!, ps[startp + 2]!, ps[startp + 1]!, spl.sp];
@@ -293,7 +296,7 @@ class SplineClipHelper {
     if (sflag && eflag && endp === startp) {
       // two arrows on one segment
       const p = ps[endp]!; const q = ps[endp + 3]!;
-      const d = SplineClipHelper.dist(p, q);
+      const d = dist(p, q);
       let hlen = hlen0; let tlen = tlen0;
       if (hlen + tlen >= d) { hlen = tlen = d / 3.0; }
       const s = { x: p.x, y: p.y }; const t = { x: q.x, y: q.y };
@@ -315,7 +318,7 @@ class SplineClipHelper {
     if (eflag) {
       let hlen = hlen0;
       const p = ps[endp]!; const q = ps[endp + 3]!;
-      const maxd = 0.9 * SplineClipHelper.dist(p, q);
+      const maxd = 0.9 * dist(p, q);
       if (hlen >= maxd) hlen = maxd;
       const r = { x: p.x, y: p.y };
       if (p.y === q.y) { r.y = p.y; r.x = p.x < q.x ? q.x - hlen : q.x + hlen; }
@@ -326,7 +329,7 @@ class SplineClipHelper {
     if (sflag) {
       let tlen = tlen0;
       const p = ps[startp]!; const q = ps[startp + 3]!;
-      const maxd = 0.9 * SplineClipHelper.dist(p, q);
+      const maxd = 0.9 * dist(p, q);
       if (tlen >= maxd) tlen = maxd;
       const r = { x: p.x, y: p.y };
       if (p.y === q.y) { r.y = p.y; r.x = p.x < q.x ? p.x + tlen : p.x - tlen; }

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 { agerrorf } 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');
+    agerrorf('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,7 +48,7 @@ export function getFamilyMetrics(fontName: string): FontFamilyData {
   }
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
-    console.warn(
+    agwarningf(
       `Warning: 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/context.ts

@@ -26,6 +26,7 @@ import type { DebugOptions } from '../debug.js';
 import type { ImageSizer } from '../common/htmltable-types.js';
 import type { ImageResolver } from './image-resolver.js';
 import type { RenderJob } from './job.js';  // scaffold in T25; full class in T26
+import { resetRenderState } from '../common/render-state.js';
 import { RenderError, invalidArgType, invalidArgValue } from '../errors.js';
 
 // ---------------------------------------------------------------------------
@@ -285,6 +286,12 @@ export class GvcContext {
    * rendering happens in between and must see the layout state
    * (e.g. cluster arrays).
    *
+   * Contract (AD-4/AD-8): first resets the C process state (RNG streams,
+   * sequence counters, once-only warnings), so each `layout` call behaves
+   * as one native run — drive one graph per `layout`. Caller-installed hooks
+   * (setTextMeasurer, setImageSizer, setImageResolver, the per-context
+   * measurer/sizer/resolver) are configuration and are not reset.
+   *
    * @throws TypeError (ERR_INVALID_ARG_TYPE / ERR_INVALID_ARG_VALUE) for a
    *   bad `g`, or an engine argument that is not registered
    * @throws RenderError (UNKNOWN_LAYOUT) if the `layout` attribute names no
@@ -295,6 +302,7 @@ export class GvcContext {
    * @see lib/gvc/gvlayout.c:gvLayoutJobs
    */
   layout(g: Graph, engineName: EngineName): void {
+    resetRenderState(); // AD-8: idempotent under the public entries' own reset
     const selected = this.checkLayoutArgs(g, engineName);
     // C gvLayoutJobs: the graph's `layout` ATTRIBUTE unconditionally
     // overrides the selected engine (-K / API choice); an unrecognized