@knowvah/dot-engine 2.6.11 → 2.7.0

package/src/model/lazy-attrs.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Shared empty attribute map for dot virtual nodes/edges (AD-12).
+ *
+ * C virtual nodes/edges carry no attribute record; allocating an empty `Map`
+ * per object cost ~372 B per virtual pair. Virtual objects start with this
+ * single shared map instead; reads see an empty map, and the first write goes
+ * through {@link ownAttrs}, which materialises a private `Map`. A direct
+ * mutation of the shared map throws rather than leaking into every virtual.
+ * @see lib/dotgen/fastgr.c:virtual_node
+ */
+
+class SharedEmptyAttrs extends Map<string, string> {
+  override set(key: string, _value: string): never {
+    throw new Error(`attrs.set("${key}") on a shared empty map; use ownAttrs()`);
+  }
+  override delete(key: string): never {
+    throw new Error(`attrs.delete("${key}") on a shared empty map; use ownAttrs()`);
+  }
+  override clear(): never {
+    throw new Error('attrs.clear() on a shared empty map; use ownAttrs()');
+  }
+}
+
+/** The one shared empty attribute map (read-only by construction). */
+export const EMPTY_ATTRS: Map<string, string> = new SharedEmptyAttrs();
+
+/**
+ * Return the object's private attribute map, materialising it on first write
+ * when the object still holds {@link EMPTY_ATTRS}.
+ */
+export function ownAttrs(o: { attrs: Map<string, string> }): Map<string, string> {
+  if (o.attrs === EMPTY_ATTRS) o.attrs = new Map();
+  return o.attrs;
+}

package/src/model/node.ts

@@ -8,6 +8,7 @@
 
 import type { Edge } from './edge.js';
 import type { Graph } from './graph.js';
+import { EMPTY_ATTRS } from './lazy-attrs.js';
 import { type NodeInfo, makeNodeInfo } from './nodeInfo.js';
 
 /**
@@ -64,10 +65,10 @@ export class Node {
   nodeDefaultsSnapshot?: Map<string, string>;
 
   /** @see lib/cgraph/node.c:agnode */
-  constructor(id: number, name: string, root: Graph) {
+  constructor(id: number, name: string, root: Graph, lazyAttrs = false) {
     this.id = id;
     this.name = name;
-    this.attrs = new Map();
+    this.attrs = lazyAttrs ? EMPTY_ATTRS : new Map();
     this.info = makeNodeInfo();
     this.root = root;
   }

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 { agwarningf } from '../common/agerr.js';
 
 export type { OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint, ClipAndInstallFn };
 export { SEED } from "./partition.js";
@@ -144,7 +145,7 @@ export function orthoEdges(
   clipAndInstall?: ClipAndInstallFn,
 ): number {
   if (useLbls) {
-    console.warn(
+    agwarningf(
       "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");
     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");
       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));
   }
 }
 
@@ -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;
   }

package/src/render/color-resolve.ts

@@ -18,10 +18,17 @@
 
 import {
   colorxlate,
+  ColorxlateResult,
   getColorScheme,
   setColorScheme,
   type GVColor,
 } from '../common/color.js';
+import type { Edge } from '../model/edge.js';
+import { registerRenderState } from '../common/render-state.js';
+import { agerrorf, agwarningf } from '../common/agerr.js';
+import { parseSegsSilent } from '../common/multicolor.js';
+import { findStopColor, styleTokens } from '../common/style-resolve.js';
+import { emitOnce } from '../common/emit-once.js';
 
 /**
  * The SVG renderer's known color names, ported verbatim from
@@ -78,19 +85,70 @@ const SVG_KNOWN_COLORS: readonly string[] = [
 /** Lower-cased lookup set for the SVG known colors (case-insensitive, as C). */
 export const KNOWN_COLORS: ReadonlySet<string> = new Set(SVG_KNOWN_COLORS);
 
+/**
+ * Whether the active renderer has the SVG known-colors list (svg). Only then
+ * does a known name skip colorxlate; every other renderer runs colorxlate on
+ * every name, which under a colorscheme can reject a name the list accepts.
+ * Per render (AD-4); a render that sets nothing is svg.
+ * @see lib/gvc/gvrender.c:195-199 gvrender_resolve_color (knowncolors)
+ */
+const rendererColors = { hasKnownList: true };
+registerRenderState(() => {
+  rendererColors.hasKnownList = true;
+});
+
+/** Select the active renderer's known-colors behaviour; svg is the only list. */
+export function setRendererKnownColors(hasList: boolean): void {
+  rendererColors.hasKnownList = hasList;
+}
+
+/**
+ * The first color of a `c1:c2` list: gvrender_set_pencolor cuts the name at the
+ * first ':' before resolving it.
+ * @see lib/gvc/gvrender.c:gvrender_set_pencolor
+ */
+export function firstColor(name: string): string {
+  const i = name.indexOf(':');
+  return i < 0 ? name : name.slice(0, i);
+}
+
 /**
  * Resolve a raw color string to a canonical {@link GVColor} for rendering.
  *
+ * `report` false resolves without the unknown-color warning, for a caller that
+ * resolves earlier than C does (the warning belongs to C's own call order).
+ *
  * @see lib/gvc/gvrender.c:188-213 gvrender_resolve_color
  */
-export function resolveRenderColor(raw: string): GVColor {
+export function resolveRenderColor(raw: string, report = true): GVColor {
   if (raw === '' || raw === 'none') return { type: 'none' };
   // C keeps a known name verbatim (case preserved); only the compare is
   // case-insensitive (bsearch over a lowercase table).
-  if (KNOWN_COLORS.has(raw.toLowerCase())) return { type: 'string', s: raw };
+  const known = KNOWN_COLORS.has(raw.toLowerCase());
+  if (known && (rendererColors.hasKnownList || !report)) return { type: 'string', s: raw };
   const color: GVColor = { type: 'rgba', r: 0, g: 0, b: 0, a: 0 };
-  colorxlate(raw, color, 'rgba');
-  return color;
+  const rc = colorxlate(raw, color, 'rgba');
+  if (report) reportColorxlate(raw, rc);
+  return known ? { type: 'string', s: raw } : color;
+}
+
+/**
+ * The non-OK branch of gvrender_resolve_color: an unknown name warns once per
+ * render (emit_once "color <name>"), any other failure is an error.
+ *
+ * The result is renderer independent: every renderer's known-colors list is
+ * either absent (dot, xdot, json, cmapx, ...) or the SVG list, whose names all
+ * colorxlate to COLOR_OK, so only the xlate result decides whether C warns.
+ *
+ * @see lib/gvc/gvrender.c:201-209 gvrender_resolve_color
+ */
+function reportColorxlate(name: string, rc: ColorxlateResult): void {
+  if (rc === ColorxlateResult.ColorOk) return;
+  if (rc === ColorxlateResult.ColorUnknown) {
+    if (emitOnce(`color ${name}`)) agwarningf(`${name} is not a known color.`);
+  } else {
+    agerrorf('error in colorxlate()');
+  }
 }
 
 /**
@@ -169,3 +227,134 @@ export function textFillAttrs(fontColor: string | null): string {
   if (byte < 255) out += ' fill-opacity="' + (byte / 255).toFixed(6) + '"';
   return out;
 }
+
+// ---------------------------------------------------------------------------
+// Unknown-color reporting in C's call order
+//
+// Which names C hands to gvrender_resolve_color, and in what order, is fixed by
+// the emit code (emit_edge_graphics, emit_background, emit_label, ...), not by
+// the renderer. The port's renderers resolve in their own order and not at all
+// for the non-drawing ones (plain, imap, cmapx), so each pass below lists the
+// names in C's order and resolves them once, before any renderer code runs;
+// emit_once then makes every later resolve of the same name silent.
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/const.h DEFAULT_COLOR */
+const DEFAULT_COLOR = 'black';
+/** @see lib/common/emit.c:452 AEQ0 (EPS) */
+const SEG_EPS = 1e-5;
+
+/**
+ * Resolve each name as gvrender_set_pencolor/_fillcolor/_gradient_vals would
+ * (cut at the first ':'), reporting unknown colors.
+ */
+export function reportColorNames(names: readonly string[]): void {
+  for (const name of names) resolveRenderColor(firstColor(name));
+}
+
+/** The per-bezier arrow flags emit_edge_graphics consults. */
+export interface EdgeArrowFlags {
+  sflag: boolean;
+  eflag: boolean;
+}
+
+/** The inputs of emit_edge_graphics' colour decisions. */
+export interface EdgeColorSpec {
+  /** late_string(e, E_color, ""). */
+  color: string;
+  /** E_fillcolor when set and non-empty, else "". */
+  fillcolor: string;
+  tapered: boolean;
+  arrows: readonly EdgeArrowFlags[];
+}
+
+/** Count occurrences of one character. */
+function countChar(s: string, ch: string): number {
+  return s.split(ch).length - 1;
+}
+
+/**
+ * The colours C's multicolor() sets, or null when the colour spec is rejected
+ * (parseSegs rv 1 or 2) and emit_edge_graphics falls back to DEFAULT_COLOR.
+ * @see lib/common/emit.c:1975 multicolor
+ */
+function multicolorNames(
+  color: string,
+  arrows: readonly EdgeArrowFlags[],
+): string[] | null {
+  const { segs, error } = parseSegsSilent(color);
+  if (error === 1 || error === 2) return null;
+  const out: string[] = [];
+  const front = segs[0]?.color ?? null;
+  for (const bz of arrows) {
+    let endcolor: string | null = null;
+    for (const seg of segs) {
+      if (seg.color === null) break;
+      if (Math.abs(seg.t) < SEG_EPS) continue;
+      out.push(seg.color);
+      endcolor = seg.color;
+    }
+    if (bz.sflag && front !== null) out.push(front);
+    if (bz.eflag && endcolor !== null) out.push(endcolor);
+  }
+  return out;
+}
+
+/** The tapered branch: transparent pen, colour as fill, then pen and fill. */
+function taperedNames(color: string, fillcolor: string, hasFill: boolean): string[] {
+  const pen = color === '' ? DEFAULT_COLOR : color;
+  return hasFill ? [pen, fillcolor === '' ? DEFAULT_COLOR : fillcolor] : [pen];
+}
+
+/**
+ * The names emit_edge_graphics resolves for an edge with a spline, in order.
+ * @see lib/common/emit.c:2350 emit_edge_graphics
+ */
+export function edgeGraphicsColors(spec: EdgeColorSpec): string[] {
+  const numc = countChar(spec.color, ':');
+  let color = spec.color;
+  if (countChar(color, ';') > 0 && numc > 0) {
+    const multi = multicolorNames(color, spec.arrows);
+    if (multi !== null) return multi;
+    color = DEFAULT_COLOR;
+  }
+  const hasFill = spec.fillcolor !== '';
+  const early = hasFill ? [spec.fillcolor] : [];
+  if (spec.tapered) return [...early, ...taperedNames(color, spec.fillcolor, hasFill)];
+  if (numc > 0) return [...early, ...color.split(':').filter((c) => c !== '')];
+  const fill = hasFill ? spec.fillcolor : color;
+  if (color !== '') return [...early, color, fill];
+  return [...early, DEFAULT_COLOR, fill !== '' ? fill : DEFAULT_COLOR];
+}
+
+/**
+ * Report the unknown colours of an edge's graphics in C's order.
+ * @see lib/common/emit.c:2350 emit_edge_graphics
+ */
+export function reportEdgeColors(e: Edge): void {
+  const spl = e.info.spl;
+  if (!spl) return;
+  const color = e.attrs.get('color') ?? '';
+  reportColorNames(edgeGraphicsColors({
+    color,
+    fillcolor: e.attrs.get('fillcolor') ?? '',
+    tapered: styleTokens(e.attrs.get('style')).includes('tapered'),
+    arrows: spl.list.map((bz) => ({ sflag: bz.sflag !== 0, eflag: bz.eflag !== 0 })),
+  }));
+}
+
+/**
+ * The names emit_background resolves: the fill (a gradient's first colour, the
+ * transparent pen, then the stop). Only a truecolor device (svg) keeps a
+ * transparent background unpainted; elsewhere it becomes white.
+ * @see lib/common/emit.c:1476 emit_background
+ */
+export function backgroundColors(bgcolor: string | undefined, truecolor: boolean): string[] {
+  let str = bgcolor !== undefined && bgcolor !== '' ? bgcolor : 'white';
+  if (str === 'transparent') {
+    if (truecolor) return [];
+    str = 'white';
+  }
+  const stop = findStopColor(str);
+  return stop === null ? [str, 'transparent'] : [stop.fillColor, 'transparent', stop.stopColor];
+}

package/src/render/dot/edge-draw.ts

@@ -23,11 +23,12 @@ import { resolveRenderColor } from '../color-resolve.js';
 import { taper, taperfun } from '../../common/taper.js';
 import { orthoRoundedRadius } from '../svg-helpers.js';
 import { orthoRoundedPolylines } from '../svg-edge-ortho-radius.js';
-import { parseSegs } from '../../common/multicolor.js';
+import { edgeSegsContext, parseSegs, parseSegsSilent } from '../../common/multicolor.js';
 import { splitSplineByColor } from '../svg-edge-split.js';
 import { buildOffsetLists, advanceTmpList } from '../../common/edge-offset.js';
 import { xdotFillColor, xdotNum, xdotPenColor, xdotPoint, xdotPoints, xdotStrOp, trimFixed3 } from './xdot-ops.js';
 import { DotWriterBase } from './agwrite.js';
+import { gvrenderSetStyle } from '../../gvc/gvrender-set-style.js';
 
 /** Pen colour when a colour-list entry is empty. @see lib/common/emit.c:2485 */
 const DEFAULT_COLOR = 'black';
@@ -81,6 +82,7 @@ export abstract class EdgeDrawBase extends DotWriterBase {
    */
   attachmentPolyline(pts: Point[], pencolor: string, job: RenderJob): void {
     const obj = job.obj;
+    gvrenderSetStyle(DEFAULT_LINE_STYLE);
     if (obj !== null) {
       obj.rawStyle = [...DEFAULT_LINE_STYLE];
       obj.pen = PenType.Solid;
@@ -147,11 +149,12 @@ export abstract class EdgeDrawBase extends DotWriterBase {
    */
   protected emitSplitSpline(
     bzList: (Bezier | undefined)[],
+    e: Edge,
     colorAttr: string,
     edraw: string[],
     job: RenderJob,
   ): { firstColor: string; endColor: string } {
-    const segs = parseSegs(colorAttr).segs;
+    const segs = parseSegs(colorAttr, edgeSegsContext(e)).segs;
     const firstColor = segs[0]?.color ?? DEFAULT_COLOR;
     let endColor = firstColor;
     for (const bz of bzList) {
@@ -183,7 +186,7 @@ export abstract class EdgeDrawBase extends DotWriterBase {
         ? buildOffsetLists(bz.list, (2 + numc) / 2)
         : { offlist: [] as Point[], tmplist: [] as Point[] },
     );
-    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR);
+    const colors = parseSegsSilent(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR);
     for (const color of colors) {
       const pen = xdotPenColor(resolveRenderColor(color));
       for (const sd of segData) {

package/src/render/dot.ts

@@ -215,7 +215,7 @@ export class XdotRenderer extends EdgeDrawBase implements RendererPlugin {
       // color segment, split along the spline's arc length. Takes precedence
       // over tapered / `:` parallel, matching C's `if (numsemi && numc)` order.
       // @see lib/common/emit.c:2389 multicolor
-      const c = this.emitSplitSpline(spl.list as (Bezier | undefined)[], colorAttr, edraw, job);
+      const c = this.emitSplitSpline(spl.list as (Bezier | undefined)[], e, colorAttr, edraw, job);
       tailArrowColor = c.firstColor;
       headArrowColor = c.endColor;
     } else if (edgeIsTapered(e)) {

package/src/render/public.ts

@@ -14,6 +14,7 @@ import type { Graph } from '../model/graph.js';
 import { createDefaultContext } from '../gvc/default-context.js';
 import { render as deviceRender } from '../gvc/device.js';
 import { invalidArgType, rethrowAtBoundary } from '../errors.js';
+import { resetRenderState } from '../common/render-state.js';
 import type { EngineName } from '../gvc/context.js';
 
 // ---------------------------------------------------------------------------
@@ -118,6 +119,7 @@ export function render(
   opts?: RenderOptions,
 ): string {
   checkRenderArgs(g, format, opts);
+  resetRenderState(); // AD-4: one render = one native process
   const engine: EngineName = opts?.engine ?? 'dot';
   const inlineImages = opts?.inlineImages ?? false;
   const ctx = createDefaultContext();

package/src/render/svg-edge-split.ts

@@ -20,7 +20,8 @@ import type { Edge } from '../model/edge.js';
 import type { RenderJob } from '../gvc/job.js';
 import type { Point, Bezier } from '../model/geom.js';
 import { bezier } from '../common/bezier.js';
-import { parseSegs } from '../common/multicolor.js';
+import { dist2 } from '../common/spline-midpoint.js';
+import { edgeSegsContext, parseSegs } from '../common/multicolor.js';
 import { transformPoint } from '../gvc/device.js';
 import { emitBezierPath, emitDash, emitPenWidth } from './svg-helpers.js';
 import { resolveRenderColor, colorPaint } from './color-resolve.js';
@@ -31,12 +32,13 @@ const PENWIDTH_THRESHOLD = 0.005;
 /** AEQ0 tolerance for fraction comparisons. */
 const EPS = 1e-5;
 
+/** DIST: sqrt of the fused DIST2 (libgvc splitBSpline: fmla + fsqrt). @see lib/common/geom.h:DIST */
 function dist(a: Point, b: Point): number {
-  return Math.hypot(a.x - b.x, a.y - b.y);
+  return Math.sqrt(dist2(a, b));
 }
 
 /** Chord length of one cubic (control points at off..off+3). @see emit.c:1908 */
-function approxLen(list: Point[], off: number): number {
+export function approxLen(list: Point[], off: number): number {
   return dist(list[off]!, list[off + 1]!) +
     dist(list[off + 1]!, list[off + 2]!) +
     dist(list[off + 2]!, list[off + 3]!);
@@ -158,7 +160,7 @@ export function emitSplitEdgePaths(
   job: RenderJob,
   colorList: string,
 ): { firstColor: string; endColor: string } {
-  const segs = parseSegs(colorList).segs;
+  const segs = parseSegs(colorList, edgeSegsContext(e)).segs;
   const firstColor = segs[0]?.color ?? DEFAULT_COLOR;
   const spl = e.info.spl;
   let endColor = firstColor;

package/src/render/svg-multicolor.ts

@@ -231,8 +231,9 @@ function drawWedge(seg: WedgeSeg, e: EllipseParams, ctx: RenderCtx): number {
  */
 export function wedgedEllipse(
   job: RenderJob, pf: Point[], clrs: string, renderer: RendererPlugin,
+  context?: () => string,
 ): number {
-  const { segs, error } = parseSegs(clrs);
+  const { segs, error } = parseSegs(clrs, context);
   if (error === 1 || error === 2) return error;
   const ctrX = (pf[0]!.x + pf[1]!.x) / 2;
   const ctrY = (pf[0]!.y + pf[1]!.y) / 2;
@@ -286,9 +287,9 @@ function drawBand(p: Point[], seg: BandSeg, ctx: RenderCtx): void {
  */
 export function stripedBox(
   job: RenderJob, pts: Point[], clrs: string,
-  rotate: boolean, renderer: RendererPlugin,
+  rotate: boolean, renderer: RendererPlugin, context?: () => string,
 ): number {
-  const { segs, error } = parseSegs(clrs);
+  const { segs, error } = parseSegs(clrs, context);
   if (error === 1 || error === 2) return error;
   // @see lib/common/emit.c:605-615 rotate swap
   const p: Point[] = rotate

package/src/render/svg-parallel-edge.ts

@@ -27,7 +27,7 @@ import { buildOffsetLists, advanceTmpList } from '../common/edge-offset.js';
 import { transformPoint } from '../gvc/device.js';
 import { emitBezierPath, emitDash, emitPenWidth } from './svg-helpers.js';
 import { resolveRenderColor, colorPaint, colorOpacity } from './color-resolve.js';
-import { parseSegs } from '../common/multicolor.js';
+import { parseSegsSilent } from '../common/multicolor.js';
 
 const PENWIDTH_NORMAL = 1.0;
 const PENWIDTH_THRESHOLD = 0.005;
@@ -114,7 +114,7 @@ export function emitParallelEdgePaths(
   // parseSegs strips any ';weight', so the semicolon syntax (which C routes
   // to split-along-length multicolor — a follow-up) at least yields valid
   // parallel colors instead of an invalid "red;0.5" stroke.
-  const colors = parseSegs(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR);
+  const colors = parseSegsSilent(colorList).segs.map((s) => s.color ?? DEFAULT_COLOR);
   emitColorPasses(segData, colors, job);
   return {
     headColor: colors[0] ?? DEFAULT_COLOR,

package/src/render/xdot-public.ts

@@ -35,6 +35,7 @@ import { createDefaultContext } from '../gvc/default-context.js';
 import { parseXDot } from '../xdot/index.js';
 import type { EngineName } from '../gvc/context.js';
 import { invalidArgType, rethrowAtBoundary } from '../errors.js';
+import { resetRenderState } from '../common/render-state.js';
 
 /**
  * `Xdot` — the parsed result of one xdot attribute stream: `ops` (the
@@ -160,6 +161,7 @@ function layoutAndRenderXdot(g: Graph, engine: EngineName): string {
  */
 export function getDrawOps(g: Graph, opts?: DrawOpsOptions): XdotOp[] {
   checkDrawOpsArgs(g, opts);
+  resetRenderState(); // AD-4: one render = one native process
   const engine = opts?.engine ?? DEFAULT_DRAW_ENGINE;
   return collectGraphOps(parse(layoutAndRenderXdot(g, engine)));
 }