@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/gvc/device-cluster.ts

@@ -6,14 +6,19 @@
 
 import type { Graph } from '../model/graph.js';
 import type { ObjState } from './job.js';
+import type { RendererPlugin } from './context.js';
+import { transformPoint } from './device-transform.js';
+import { stripedBox } from '../render/svg-multicolor.js';
 import { RenderJob } from './job.js';
 import { FillType } from './context.js';
 import type { ResolvedFill, ClusterAttrs } from '../common/style-resolve.js';
 import {
   parseStyleFlags, resolvePenColor, resolvePenType, resolvePenWidth,
-  resolveClusterFillEx,
+  resolveClusterFillEx, styleTokens,
 } from '../common/style-resolve.js';
-import { resolveRenderColor, withColorScheme } from '../render/color-resolve.js';
+import { gvrenderSetStyle, checkClusterStyleTokens } from './gvrender-set-style.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.
@@ -99,16 +104,94 @@ export function applyClusterObjState(sg: Graph, job: RenderJob): boolean {
   const fillRes = resolveClusterFillEx(clusterAttrsOf(sg));
   if (job.obj === null) return false;
   const obj = job.obj;
+  // emit_clusters: gvrender_set_style(job, checkClusterStyle list) precedes the
+  // colour resolution. @see lib/common/emit.c:3808
+  gvrenderSetStyle(checkClusterStyleTokens(styleTokens(clusterStyle(sg))));
   // 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;
   });
 }
+
+/**
+ * True when emit_clusters takes the striped branch: `style=striped` and not
+ * `rounded` (the rounded branch is tested first).
+ * @see lib/common/emit.c:3877-3892 emit_clusters (rounded / striped / plain)
+ */
+export function isStripedCluster(sg: Graph): boolean {
+  const flags = parseStyleFlags(clusterStyle(sg));
+  return flags.striped && !flags.rounded;
+}
+
+/**
+ * The fillcolor string emit_clusters hands to stripedBox.
+ * @see lib/common/emit.c:3820-3850 emit_clusters (fillcolor selection)
+ */
+function stripedFillSpec(sg: Graph): string {
+  const flags = parseStyleFlags(clusterStyle(sg));
+  const color = clusterAttr(sg, 'color') ?? '';
+  let fill = clusterAttr(sg, 'fillcolor') || color;
+  const bg = clusterAttr(sg, 'bgcolor') ?? '';
+  if ((!flags.filled || fill === '') && bg !== '') fill = bg;
+  return fill === '' ? 'lightgrey' : fill;
+}
+
+/**
+ * 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[] {
+  if (!isStripedCluster(sg)) return [];
+  const { segs, error } = parseSegs(stripedFillSpec(sg), () => `in cluster ${sg.name}`);
+  if (error === 1 || error === 2) return [];
+  return segs.flatMap((seg) => (seg.color !== null && seg.t > 0 ? [seg.color] : []));
+}
+
+/**
+ * Draw a `style=striped` cluster box: stripedBox over the bb corners, then the
+ * unfilled bb outline (pen already "transparent" for `peripheries=0`). The
+ * once-per-render Total-size warning is claimed by stripedClusterColors when
+ * the pen state is applied, so the parse here does not print twice.
+ * @see lib/common/emit.c:3892-3906 emit_clusters (striped branch)
+ */
+export function renderStripedClusterBox(
+  sg: Graph, renderer: RendererPlugin, job: RenderJob,
+): void {
+  // stripedBox runs inside emit_clusters' setColorScheme window (3800/3943).
+  withColorScheme(clusterAttr(sg, 'colorscheme'), () => {
+    const { ll, ur } = sg.info.bb!;
+    const af = [
+      { x: ll.x, y: ll.y }, { x: ur.x, y: ll.y }, { x: ur.x, y: ur.y }, { x: ll.x, y: ur.y },
+    ].map((p) => transformPoint(p, job));
+    // stripedBox passes filled=1 (never GRADIENT) to gvrender_polygon; the port's
+    // renderers read the gradient from obj.fill, so show them a solid fill.
+    const obj = job.obj;
+    const savedFill = obj?.fill;
+    if (obj !== null && savedFill !== undefined) obj.fill = FillType.Solid;
+    stripedBox(job, af, stripedFillSpec(sg), false, renderer, () => `in cluster ${sg.name}`);
+    if (obj !== null && savedFill !== undefined) obj.fill = savedFill;
+    const rawPts = [
+      { x: ll.x, y: ll.y }, { x: ll.x, y: ur.y }, { x: ur.x, y: ur.y }, { x: ur.x, y: ll.y },
+    ];
+    renderer.polygon(rawPts.map((p) => transformPoint(p, job)), false, job);
+  });
+}
+
+/** 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

@@ -26,6 +26,7 @@ import type { ShapeDesc, TextlabelT } from '../common/types.js';
 import { type LayerInfo, parseLayers } from '../common/layers.js';
 import { RenderJob, EMIT_CLUSTERS_LAST, createObjState, ObjType, EmitState } from './job.js';
 import { walkNodesAndEdges } from './emit-walk.js';
+import { warnLayersUnsupported } from './first-layer.js';
 import { polyInit } from '../common/poly-init.js';
 import {
   setHtmlAnchorObj,
@@ -42,11 +43,15 @@ 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 { applyClusterObjState, clusterStyle, clusterPeripheries, isStripedCluster, renderStripedClusterBox } from './device-cluster.js';
 import { transformPoint } from './device-transform.js';
-import { renderOneLabel, renderNodeXLabel, renderClusterLabel } from './device-labels.js';
+import { gvrenderSetStyle, edgeStyleResets } from './gvrender-set-style.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,12 +161,15 @@ 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
   // reads only obj.pen, so this is xdot-only. @see gvrender_core_dot.c xdot_style
   obj.rawStyle = styleTokens(e.attrs.get('style'));
+  // emit_begin_edge: `if (styles && ED_spl(e)) gvrender_set_style(job, styles)`
+  // @see lib/common/emit.c:2726
+  if (e.info.spl !== undefined) gvrenderSetStyle(obj.rawStyle);
 }
 
 export function renderEdge(e: Edge, renderer: RendererPlugin, job: RenderJob): void {
@@ -189,6 +197,14 @@ 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);
+      // arrow_gen resets the style; C sets the edge's styles again after each
+      // flagged bezier of a multi-bezier spline. @see emit.c:2047, :2677
+      const styles = styleTokens(e.attrs.get('style'));
+      for (let i = edgeStyleResets(e, styles); i > 0; i--) gvrenderSetStyle(styles);
+      reportEdgeLabelColors(e);
       renderer.endEdge(e, job);
     });
   } finally {
@@ -223,6 +239,10 @@ function renderClusterBox(
   sg: Graph, filled: boolean, renderer: RendererPlugin, job: RenderJob,
 ): void {
   const { ll, ur } = sg.info.bb!;
+  if (isStripedCluster(sg)) {
+    renderStripedClusterBox(sg, renderer, job);
+    return;
+  }
   if (parseStyleFlags(clusterStyle(sg)).rounded) {
     const af = [{ x: ll.x, y: ll.y }, { x: ur.x, y: ll.y }, { x: ur.x, y: ur.y }, { x: ll.x, y: ur.y }];
     emitRoundedBezier(af, { x: 0, y: 0 }, filled, { renderer, job });
@@ -273,7 +293,7 @@ function renderOneCluster(sg: Graph, renderer: RendererPlugin, job: RenderJob):
     // style=invis sets PEN_NONE and gvrender_polygon skips the whole box
     // (fill included); the group/title still emit.
     // @see lib/common/emit.c:3907-3917, lib/gvc/gvrender.c:543
-    if ((clusterPeripheries(sg) !== 0 || filled) && job.obj?.pen !== PenType.None) {
+    if ((clusterPeripheries(sg) !== 0 || filled || isStripedCluster(sg)) && job.obj?.pen !== PenType.None) {
       renderClusterBox(sg, filled, renderer, job);
     }
     renderClusterLabel(sg, renderer, job);
@@ -327,6 +347,7 @@ export function renderGraph(g: Graph, job: RenderJob, renderer: RendererPlugin):
     job.numLayers = layered ? info.numLayers : 1;
     job.layerIDs = info.layerIDs;
     renderer.beginGraph(g, job);
+    warnLayersUnsupported(job.format, info.numLayers, renderer.beginLayer !== undefined);
     for (let ln = 1; ln <= job.numLayers; ln++) {
       job.layerNum = ln;
       if (layered) renderer.beginLayer!(info.layerIDs[ln]!, job);
@@ -351,9 +372,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 +484,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/gvc/first-layer.ts

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * The `GVDEVICE_DOES_LAYERS` check of `firstlayer`: a device without it prints
+ * one layer and warns. The one-layer effect is `renderGraph`'s `layered` flag
+ * (only svg has `beginLayer`; the other native layer-capable devices, ps/pov,
+ * are not ported); this file owns the warning.
+ */
+import { agwarningf } from '../common/agerr.js';
+
+/** Port format ids that spell a native `-T` name differently (`output_langname`). */
+const NATIVE_LANGNAME: ReadonlyMap<string, string> = new Map([
+  ['cmapx-np', 'cmapx_np'],
+  ['imap-np', 'imap_np'],
+]);
+
+/**
+ * Print `layers not supported in <output_langname> output` when the graph has
+ * more than one layer and the device cannot draw layers. Called after
+ * beginGraph, as emit_graph calls firstlayer after emit_begin_graph: for
+ * `-Tjson` the nested xdot render in json_begin_graph therefore warns first.
+ * @see lib/common/emit.c:firstlayer
+ */
+export function warnLayersUnsupported(format: string, numLayers: number, doesLayers: boolean): void {
+  if (numLayers <= 1 || doesLayers) return;
+  agwarningf(`layers not supported in ${NATIVE_LANGNAME.get(format) ?? format} output`);
+}

package/src/gvc/gvrender-set-style.ts

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * The warning half of `gvrender_set_style`, plus the style-list filters its
+ * callers apply first. The pen/width/fill mapping of the same C function is
+ * not duplicated here: the port resolves it through style-resolve.ts
+ * (parseStyleFlags, resolvePenType, resolvePenWidth), which already mirrors
+ * the token cases below. Every caller in the port runs inside a render with a
+ * render engine (`if (gvre)` in C), so no engine test is needed here.
+ *
+ * @see lib/gvc/gvrender.c:480 gvrender_set_style
+ */
+
+import { agwarningf } from '../common/agerr.js';
+import { parseSegsSilent } from '../common/multicolor.js';
+import type { PolygonT } from '../common/types.js';
+import type { Edge } from '../model/edge.js';
+
+/** Tokens gvrender_set_style maps to pen, pen width or fill state. */
+const SUPPORTED_STYLES: ReadonlySet<string> = new Set([
+  'solid', 'dashed', 'dotted', 'invis', 'invisible', 'bold', 'setlinewidth',
+  'filled', 'unfilled', 'tapered',
+]);
+
+/** `fmod(orientation, 90)` bound of shapes.c:isBox. @see lib/common/shapes.c:isBox */
+const BOX_ORIENTATION_TOLERANCE = 0.5;
+const BOX_ORIENTATION_STEP = 90;
+const BOX_SIDES = 4;
+/** polygon_t.sides bound of shapes.c:isEllipse. @see lib/common/shapes.c:isEllipse */
+const ELLIPSE_MAX_SIDES = 2;
+
+/** The name C compares: parse_style stores a token's `(args)` after its NUL. */
+function styleName(token: string): string {
+  const paren = token.indexOf('(');
+  return paren < 0 ? token : token.slice(0, paren);
+}
+
+/**
+ * Warn for every token the render engine cannot map, on every call.
+ * @see lib/gvc/gvrender.c:480 gvrender_set_style
+ */
+export function gvrenderSetStyle(styles: readonly string[] | null): void {
+  if (styles === null) return;
+  for (const token of styles) {
+    const name = styleName(token);
+    if (!SUPPORTED_STYLES.has(name)) {
+      agwarningf(`gvrender_set_style: unsupported style ${name} - ignoring`);
+    }
+  }
+}
+
+/** @see lib/common/shapes.c:isBox */
+function isBox(p: PolygonT | null): boolean {
+  if (p === null) return false;
+  return p.sides === BOX_SIDES
+    && Math.abs(p.orientation % BOX_ORIENTATION_STEP) < BOX_ORIENTATION_TOLERANCE
+    && p.distortion === 0 && p.skew === 0;
+}
+
+/** @see lib/common/shapes.c:isEllipse */
+function isEllipse(p: PolygonT | null): boolean {
+  return p !== null && p.sides <= ELLIPSE_MAX_SIDES;
+}
+
+/**
+ * The node style list passed to the renderer: checkStyle removes the tokens
+ * it turns into polygon flags. `shape` is `ND_shape(n)->polygon` (null for
+ * records).
+ * @see lib/common/shapes.c:465 checkStyle
+ */
+export function checkStyleTokens(styles: readonly string[], shape: PolygonT | null): string[] {
+  return styles.filter((p) => {
+    if (p === 'rounded' || p === 'diagonals' || p === 'radial') return false;
+    if (p === 'striped') return !isBox(shape);
+    if (p === 'wedged') return !isEllipse(shape);
+    return true;
+  });
+}
+
+/**
+ * The cluster style list passed to the renderer.
+ * @see lib/common/emit.c:367 checkClusterStyle
+ */
+export function checkClusterStyleTokens(styles: readonly string[]): string[] {
+  return styles.filter((p) => p !== 'radial' && p !== 'striped' && p !== 'rounded');
+}
+
+/** Count of `ch` in `s`. */
+function countChar(s: string, ch: string): number {
+  return [...s].filter((c) => c === ch).length;
+}
+
+/** True when emit_edge_graphics' multicolor() accepts the colour list. */
+function multicolorTaken(color: string): boolean {
+  if (countChar(color, ';') === 0 || countChar(color, ':') === 0) return false;
+  const { error } = parseSegsSilent(color);
+  return error !== 1 && error !== 2;
+}
+
+/**
+ * How many extra `gvrender_set_style(job, styles)` calls emit_edge_graphics
+ * makes: one per bezier carrying an arrow, when the spline has several
+ * beziers, in the `;` multicolor branch (when its colour list parses) and in
+ * the plain branch. The tapered and parallel `:` branches make none.
+ * @see lib/common/emit.c:2047 multicolor · :2677 emit_edge_graphics
+ */
+export function edgeStyleResets(e: Edge, styles: readonly string[]): number {
+  const spl = e.info.spl;
+  if (spl === undefined || spl.size <= 1 || styles.length === 0) return 0;
+  const color = e.attrs.get('color') ?? '';
+  const otherBranch = styles.includes('tapered') || countChar(color, ':') > 0;
+  if (otherBranch && !multicolorTaken(color)) return 0;
+  return spl.list.filter((bz) => bz.sflag !== 0 || bz.eflag !== 0).length;
+}

package/src/gvc/usershape.ts

@@ -15,6 +15,7 @@
 
 import { invalidArgType } from '../errors.js';
 import type { ImageSizer } from '../common/htmltable-types.js';
+import { findImageBytes, type ImageResolver } from './image-resolver.js';
 
 export type { ImageSizer } from '../common/htmltable-types.js';
 
@@ -37,3 +38,28 @@ export function setImageSizer(sizer: ImageSizer | null): void {
 export function findImageSize(src: string): { w: number; h: number } | null {
   return activeSizer !== null ? activeSizer(src) : null;
 }
+
+/**
+ * `strerror(ENOENT)`: the port has no filesystem, so an image the caller
+ * cannot supply is C's missing file (AD-11).
+ */
+export const STRERROR_ENOENT = 'No such file or directory';
+
+/**
+ * Whether the caller supplies `name` at all: a size from `sizer` (default: the
+ * global one) or resolver bytes (a per-context `resolver` replaces the global). Mirrors gvusershape_open
+ * finding the file.
+ */
+export function imageIsSupplied(name: string, sizer?: ImageSizer, resolver?: ImageResolver): boolean {
+  const size = sizer !== undefined ? sizer(name) : findImageSize(name);
+  return size !== null || findImageBytes(name, resolver) !== null;
+}
+
+/**
+ * The `agwarningf` text `gvusershape_file_access` prints when it cannot open
+ * `name`. C does not cache a failed open, so every sizing request repeats it.
+ * @see lib/gvc/gvusershape.c:gvusershape_file_access
+ */
+export function imageOpenWarning(name: string): string {
+  return `${STRERROR_ENOENT} while opening ${name}`;
+}

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}`);
     agDeleteFromCluster(clust, n);
     return;
   }

package/src/layout/dot/compound.ts

@@ -12,10 +12,9 @@ import type { Edge } from '../../model/edge.js';
 import {
   inBoxf, midPointf, splineIntersectf, boxIntersectf,
 } from './compound-clip.js';
-import { arrowEndClip, tailArrowEndClip, arrowClipLength } from './edge-route-clip.js';
+import { arrowEndClip, tailArrowEndClip, arrowClipLength, distFused } from './edge-route-clip.js';
 import { arrowDrawOpsForEnd, edgeArrowName, edgeArrowsize } from './edge-route-arrow.js';
 import { edgePenwidthAttr, edgeRenderPenwidth } from './edge-route-helpers.js';
-import { dist } from '../../common/arrows-geometry.js';
 
 // Re-export geometry helpers so existing callers (tests) import from one place.
 export {
@@ -67,7 +66,7 @@ function arrowEndClipIdx(state: ClipState, endp: number): number {
   const elen = arrowClipLength(edgeArrowName(e, 'head'), edgeArrowsize(e), edgePenwidthAttr(e));
   bez.eflag = bez.eflag || 1;
   bez.ep = { ...bez.list[endp + 3] };
-  if (endp > state.starti && dist(bez.list[endp], bez.list[endp + 3]) < elen) endp -= 3;
+  if (endp > state.starti && distFused(bez.list[endp], bez.list[endp + 3]) < elen) endp -= 3;
   const seg = [bez.list[endp], bez.list[endp + 1], bez.list[endp + 2], bez.list[endp + 3]];
   const clipped = arrowEndClip(seg, bez.ep, elen);
   for (let k = 0; k < 4; k++) bez.list[endp + k] = clipped[k];
@@ -83,7 +82,7 @@ function arrowStartClipIdx(state: ClipState, startp: number, endp: number): numb
   const slen = arrowClipLength(edgeArrowName(e, 'tail'), edgeArrowsize(e), edgePenwidthAttr(e));
   bez.sflag = bez.sflag || 1;
   bez.sp = { ...bez.list[startp] };
-  if (endp > startp && dist(bez.list[startp], bez.list[startp + 3]) < slen) startp += 3;
+  if (endp > startp && distFused(bez.list[startp], bez.list[startp + 3]) < slen) startp += 3;
   const seg = [bez.list[startp], bez.list[startp + 1], bez.list[startp + 2], bez.list[startp + 3]];
   const clipped = tailArrowEndClip(seg, bez.sp, slen);
   for (let k = 0; k < 4; k++) bez.list[startp + k] = clipped[k];

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}`);
   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 {