@knowvah/dot-engine 2.7.1 → 2.8.0

package/src/layout/neato/stress-kernel.ts

@@ -19,31 +19,24 @@ import type { Node } from '../../model/node.js';
 import { drand48 } from '../../common/random.js';
 import { bfs } from './bfs.js';
 import { dijkstra, type VtxData } from './dijkstra.js';
+import {
+  conjugateGradientMkernelFused, rightMultWithVectorFFFused, type CgMkernelOptions,
+} from './conjgrad-mkernel.js';
 import {
   copyVectorF,
   invertSqrtVec,
   invertVec,
-  maxAbsF,
   orthog1,
-  orthog1f,
   rightMultWithVectorFF,
   sqrtVecF,
   squareVec,
   vectorsInnerProductF,
-  vectorsMultAdditionF,
-  vectorsSubtractionF,
 } from './matrix-ops.js';
+import { fmaf } from './quad-prog-solve.js';
+import { OPT_EXP_FLAG, TOLERANCE_CG } from './stress.js';
 
 const fr = Math.fround;
 
-/** @see lib/neatogen/stress.h:tolerance_cg */
-const TOLERANCE_CG = 1e-3;
-
-/** Stress options bit: weight exponent (1 or 2). @see lib/neatogen/stress.h */
-export const OPT_EXP_FLAG = 2;
-/** Stress options bit: smart initialisation. @see lib/neatogen/stress.h */
-export const OPT_SMART_INIT = 1;
-
 /**
  * Packed all-pairs shortest paths over unit weights (BFS hops).
  * @see lib/neatogen/stress.c:compute_apsp_packed
@@ -115,71 +108,32 @@ export function initLayout(
   return pinned;
 }
 
-/**
- * Conjugate gradients on a packed symmetric float matrix.
- * Returns negative on error.
- * @see lib/neatogen/conjgrad.c:conjugate_gradient_mkernel
- */
-/** Mutable CG iteration state. */
-interface CgState {
-  A: Float32Array;
-  x: Float32Array;
-  b: Float32Array;
-  n: number;
-  r: Float32Array;
-  p: Float32Array;
-  Ap: Float32Array;
-  rR: number;
-}
-
-/** One CG step; returns false on a zero-length residual error. */
-function cgStep(st: CgState, last: boolean): boolean {
-  const { n } = st;
-  orthog1f(n, st.p);
-  orthog1f(n, st.x);
-  orthog1f(n, st.r);
-  rightMultWithVectorFF(st.A, n, st.p, st.Ap);
-  orthog1f(n, st.Ap);
-  const pAp = vectorsInnerProductF(n, st.p, st.Ap);
-  if (pAp === 0) return true; // C: break
-  const alpha = st.rR / pAp;
-  vectorsMultAdditionF(n, st.x, alpha, st.p);
-  if (!last) {
-    vectorsMultAdditionF(n, st.r, -alpha, st.Ap);
-    const rRNew = vectorsInnerProductF(n, st.r, st.r);
-    if (st.rR === 0) return false;
-    const betaF = fr(rRNew / st.rR);
-    st.rR = rRNew;
-    for (let j = 0; j < n; j++) st.p[j] = fr(betaF * st.p[j]!) + st.r[j]!;
-  }
-  return true;
+/** The right-multiply and conjugate-gradient kernels one caller runs. */
+interface KernelOps {
+  /** `acc + tmp*tmp`, the distance accumulation of the Laplacian build. */
+  squareAdd(tmp: number, acc: number): number;
+  rightMult(m: Float32Array, n: number, vector: Float32Array, result: Float32Array): void;
+  /** Returns nonzero on an unexpected zero residual. */
+  cg(A: Float32Array, x: Float32Array, b: Float32Array, n: number, o: CgMkernelOptions): number;
 }
 
-export function conjugateGradientMkernel(
-  A: Float32Array, x: Float32Array, b: Float32Array, n: number,
-  tol: number, maxIterations: number,
-): number {
-  const st: CgState = {
-    A, x, b, n,
-    r: new Float32Array(n),
-    p: new Float32Array(n),
-    Ap: new Float32Array(n),
-    rR: 0,
-  };
-  orthog1f(n, x);
-  orthog1f(n, b);
-  const Ax = new Float32Array(n);
-  rightMultWithVectorFF(A, n, x, Ax);
-  orthog1f(n, Ax);
-  vectorsSubtractionF(n, b, Ax, st.r);
-  copyVectorF(n, st.r, st.p);
-  st.rR = vectorsInnerProductF(n, st.r, st.r);
-
-  for (let i = 0; i < maxIterations && maxAbsF(n, st.r) > tol; i++) {
-    if (!cgStep(st, i >= maxIterations - 1)) return -1;
-  }
-  return 0;
-}
+/** The oracle's fused kernels, as `stress_majorization_kD_mkernel` runs them. */
+const FUSED_OPS: KernelOps = {
+  squareAdd: (tmp, acc) => fmaf(tmp, tmp, acc),
+  rightMult: rightMultWithVectorFFFused, cg: conjugateGradientMkernelFused,
+};
+/**
+ * The kernels as `stress_majorization_cola` (mode=ipsep) runs them: its squared
+ * distances are `square_vec` then `vectors_additionf` (two loops, so the product
+ * is rounded before the add), its inlined `right_mult_with_vector_ff` copy is not
+ * read from the disassembly (kept unfused), and its conjugate gradient is the same
+ * out-of-line `conjugate_gradient_mkernel` the kD kernel calls.
+ * @see lib/neatogen/constrained_majorization_ipsep.c:stress_majorization_cola
+ */
+const COLA_OPS: KernelOps = {
+  squareAdd: (tmp, acc) => acc + fr(tmp * tmp),
+  rightMult: rightMultWithVectorFF, cg: conjugateGradientMkernelFused,
+};
 
 /** Laplacian off-diagonal prep + diagonal degrees. @see stress.c (Laplacian computation) */
 function buildLap2(lap2: Float32Array, n: number, exp: number): void {
@@ -207,9 +161,9 @@ function buildLap2(lap2: Float32Array, n: number, exp: number): void {
 /** Per-iteration Laplacian of 1/(d_ij*|p_i-p_j|). @see stress.c (main loop head) */
 function buildLap1(
   lap1: Float32Array, lap2: Float32Array, coords: Float32Array[],
-  shape: { n: number; dim: number; exp: number },
+  shape: { n: number; dim: number; exp: number; ops: KernelOps },
 ): void {
-  const { n, dim, exp } = shape;
+  const { n, dim, exp, ops } = shape;
   const lapLength = (n * (n + 1)) / 2;
   const degrees = new Float64Array(n);
   const distAccumulator = new Float32Array(n);
@@ -222,7 +176,7 @@ function buildLap1(
       const ck = coords[k]!;
       for (let x = 0; x < len; x++) {
         const tmp = fr(ck[i]! + fr(-1 * ck[i + 1 + x]!));
-        distAccumulator[x] = distAccumulator[x]! + fr(tmp * tmp);
+        distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]!);
       }
     }
     invertSqrtVec(len, distAccumulator);
@@ -264,32 +218,34 @@ interface KernelState {
   b: Float32Array[];
   tmpCoords: Float32Array;
   constantTerm: number;
+  ops: KernelOps;
 }
 
 /** One stress evaluation. @see stress.c (compute new stress block) */
 function computeStress(st: KernelState): number {
   let stress = 0;
   for (let k = 0; k < st.dim; k++) {
-    rightMultWithVectorFF(st.lap1, st.n, st.coords[k]!, st.b[k]!);
+    st.ops.rightMult(st.lap1, st.n, st.coords[k]!, st.b[k]!);
     stress += vectorsInnerProductF(st.n, st.coords[k]!, st.b[k]!);
   }
   stress *= 2;
   stress += st.constantTerm;
   for (let k = 0; k < st.dim; k++) {
-    rightMultWithVectorFF(st.lap2, st.n, st.coords[k]!, st.tmpCoords);
+    st.ops.rightMult(st.lap2, st.n, st.coords[k]!, st.tmpCoords);
     stress -= vectorsInnerProductF(st.n, st.coords[k]!, st.tmpCoords);
   }
   return stress;
 }
 
-/** Solve one axis, respecting pinned nodes. @see stress.c (CG block) */
+/** Solve one axis, respecting pinned nodes; nonzero on a CG error. @see stress.c (CG block) */
 function solveAxis(st: KernelState, k: number, havePinned: boolean, nodes: Node[]): number {
+  const cg = { tol: TOLERANCE_CG, maxIterations: st.n };
   if (!havePinned) {
-    return conjugateGradientMkernel(st.lap2, st.coords[k]!, st.b[k]!, st.n, TOLERANCE_CG, st.n);
+    return st.ops.cg(st.lap2, st.coords[k]!, st.b[k]!, st.n, cg);
   }
   copyVectorF(st.n, st.coords[k]!, st.tmpCoords);
-  const rc = conjugateGradientMkernel(st.lap2, st.tmpCoords, st.b[k]!, st.n, TOLERANCE_CG, st.n);
-  if (rc < 0) return rc;
+  const rc = st.ops.cg(st.lap2, st.tmpCoords, st.b[k]!, st.n, cg);
+  if (rc !== 0) return rc;
   for (let i = 0; i < st.n; i++) {
     if (!isFixed(nodes[i]!)) st.coords[k]![i] = st.tmpCoords[i]!;
   }
@@ -304,6 +260,8 @@ export interface StressOpts {
   /** MODEL_* — only the resulting Dij matters here; pass it in. */
   maxi: number;
   epsilon: number;
+  /** Run the kernels as `stress_majorization_cola` does (mode=ipsep). */
+  cola?: boolean;
 }
 
 /**
@@ -338,20 +296,21 @@ export function stressMajorizationKDMkernel(
     b: Array.from({ length: dim }, () => new Float32Array(n)),
     tmpCoords: new Float32Array(n),
     constantTerm,
+    ops: o.cola === true ? COLA_OPS : FUSED_OPS,
   };
 
   let oldStress = Number.MAX_VALUE;
   let converged = false;
   let iterations = 0;
   for (; iterations < maxi && !converged; iterations++) {
-    buildLap1(st.lap1, lap2, coords, { n, dim, exp });
+    buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
     const newStress = computeStress(st);
     if (typeof process !== 'undefined' && process.env['STRESS_DEBUG'] && iterations % 5 === 0) console.error(newStress.toFixed(3));
     const change = Math.abs(oldStress - newStress);
     converged = change / oldStress < o.epsilon || newStress < o.epsilon;
     oldStress = newStress;
     for (let k = 0; k < dim; k++) {
-      if (solveAxis(st, k, havePinned, nodes) < 0) return -1;
+      if (solveAxis(st, k, havePinned, nodes) !== 0) return -1;
     }
   }
 

package/src/layout/neato/stress.ts

@@ -14,6 +14,9 @@
  * @see lib/neatogen/stress.h
  */
 
+import { agwarningf } from '../../common/agerr.js';
+import { lateInt } from '../../common/nodeinit.js';
+import type { Graph } from '../../model/graph.js';
 import type { VtxData } from './dijkstra.js';
 import {
   computeApspPacked,
@@ -41,6 +44,22 @@ export const OPT_SMART_INIT = 0x4;
 /** Exponent flag in opts bitmask (exp=2 when set, exp=1 when clear). */
 export const OPT_EXP_FLAG = 0x3;
 
+/** Name of the stress weight-exponent graph attribute. @see lib/neatogen/neatoinit.c:exp_name */
+const EXP_NAME = 'stresswt';
+
+/**
+ * The `stresswt` exponent, 1 or 2 (default 2).
+ * @see lib/neatogen/neatoinit.c:checkExp
+ */
+export function checkExp(g: Graph): number {
+  const exp = lateInt(g.attrs.get(EXP_NAME), 2, 0);
+  if (exp === 0 || exp > 2) {
+    agwarningf(`${EXP_NAME} attribute value must be 1 or 2 - ignoring`);
+    return 2;
+  }
+  return exp;
+}
+
 /** Model: MDS (user-supplied edge lengths). */
 export const MODEL_MDS = 1;
 

package/src/layout/osage/index.ts

@@ -11,6 +11,7 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { Node } from '../../model/node.js';
 import type { Box } from '../../model/geom.js';
 import type { LayoutEngine } from '../../gvc/context.js';
@@ -507,7 +508,11 @@ export function osageLayout(g: Graph): void {
 /** Recursively clear cluster arrays from g and all subclusters. */
 export function cleanupGraphs(g: Graph): void {
   const nClust = g.info.n_cluster ?? 0;
-  for (let i = 1; i <= nClust; i++) cleanupGraphs(g.info.clust![i - 1]);
+  for (let i = 1; i <= nClust; i++) {
+    const subg = g.info.clust![i - 1];
+    subg.info.label = undefined; // free_label(GD_label(subg))
+    cleanupGraphs(subg);
+  }
   g.info.clust = undefined;
   g.info.n_cluster = undefined;
 }
@@ -525,6 +530,8 @@ export function cleanupGraphs(g: Graph): void {
  * @see lib/osage/osageinit.c:osage_cleanup
  */
 export function osageCleanup(g: Graph): void {
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
   for (const n of g.nodes.values()) {
     if (n.info.alg?.kind === 'osage') n.info.alg = undefined;
   }

package/src/layout/patchwork/index.ts

@@ -15,6 +15,7 @@
  */
 
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { Node } from '../../model/node.js';
 import type { LayoutEngine } from '../../gvc/context.js';
 import { ps2inch } from '../pack/index.js';
@@ -425,6 +426,9 @@ export function patchworkEngineLayout(g: Graph): void {
 
 /** @see lib/patchwork/patchworkinit.c:patchwork_cleanup */
 export function patchworkEngineCleanup(g: Graph): void {
+  if (g.nodes.size === 0) return; // C: if (!n) return
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
   g.info.clust = undefined;
   g.info.n_cluster = undefined;
   for (const n of g.nodes.values()) { n.info.alg = undefined; }

package/src/layout/sfdp/init.ts

@@ -12,6 +12,7 @@
 
 import { RenderError } from '../../errors.js';
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import { setEdgeTypeFromAttr } from '../dot/index.js';
 import { EDGETYPE_LINE } from '../neato/splines.js';
 import { neatoInitNode } from '../neato/init.js';
@@ -264,6 +265,8 @@ export function getPos(g: Graph, dim: number): number[] {
  * @see lib/sfdpgen/sfdpinit.c:sfdp_cleanup
  */
 export function sfdpCleanup(g: Graph): void {
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge: per-node agfstout, all edges of root g
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
   for (const n of g.nodes.values()) {
     n.info.pos = undefined;
     n.info.id = undefined;

package/src/layout/twopi/init.ts

@@ -10,6 +10,7 @@
 
 import type { ShapeDesc } from '../../common/types.js';
 import type { Graph } from '../../model/graph.js';
+import { gvCleanupEdgeLabels, gvCleanupNodeLabels } from '../dot/init.js';
 import type { Node } from '../../model/node.js';
 import type { Edge } from '../../model/edge.js';
 import type { TwopiAlgData } from '../../model/nodeInfo.js';
@@ -157,23 +158,34 @@ export function adjustNodes(g: Graph): void {
 }
 
 /**
- * Release twopi-specific per-node state after layout.
+ * Free ND_alg of the first node, as twopi_layout does before spline routing.
  *
- * Mirrors the C twopi_layout cleanup: free(ND_alg(first_node)) / ND_alg = NULL
- * on the FIRST node only (the contiguous block was allocated as a single unit).
- * Other nodes' ND_alg pointers were interior offsets into that block so they
- * do not need to be freed separately.
+ * Mirrors the C twopi_layout: free(ND_alg(n)) / ND_alg(n) = NULL on the FIRST
+ * node only (the contiguous block was allocated as a single unit). Other
+ * nodes' ND_alg pointers were interior offsets into that block so they do
+ * not need to be freed separately.
  *
  * ORDERING: must be called BEFORE splineEdges because edge routing may
  * store its own data in n.info.alg.
  *
- * @see lib/twopigen/twopiinit.c:twopi_layout (free(ND_alg) placement note)
- * @see lib/twopigen/twopiinit.c:twopi_cleanup
+ * @see lib/twopigen/twopiinit.c:twopi_layout (lines 113-115)
  */
-export function twopiCleanup(g: Graph): void {
+export function twopiFreeAlg(g: Graph): void {
   const first = g.nodes.values().next().value as Node | undefined;
   if (first !== undefined && first.info.alg?.kind === 'twopi') {
     first.info.alg = undefined;
   }
-  g.info.neato_nlist = undefined;
+}
+
+/**
+ * Release twopi layout state after rendering (the engine's `cleanup`).
+ * ND_alg is freed earlier, in twopi_layout (see twopiFreeAlg).
+ *
+ * @see lib/twopigen/twopiinit.c:twopi_cleanup
+ */
+export function twopiCleanup(g: Graph): void {
+  if (g.nodes.size === 0) return; // C: empty graph
+  for (const e of g.edges) gvCleanupEdgeLabels(e); // gv_cleanup_edge
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n); // gv_cleanup_node
+  g.info.neato_nlist = undefined; // twopi_cleanup_graph
 }

package/src/layout/twopi/pipeline.ts

@@ -11,7 +11,7 @@ import type { Graph } from '../../model/graph.js';
 import type { Node } from '../../model/node.js';
 import type { PackInfo } from '../pack/index.js';
 import {
-  twopiCleanup,
+  twopiFreeAlg,
   findRootNode,
   adjustNodes,
   finaliseCoords,
@@ -71,7 +71,7 @@ export function layoutSingle(g: Graph, comps: Graph[], globalRoot: Center, setRo
   if (setRoot && globalRoot === null && center !== null) {
     g.attrs.set('root', center.name);
   }
-  twopiCleanup(g); // ORDERING: before spline routing
+  twopiFreeAlg(g); // ORDERING: before spline routing
   // C: spline_edges(g) — shifts pos to the origin, syncs coord, routes.
   splineEdgesShifted(g);
   finaliseCoords(g);
@@ -90,7 +90,7 @@ export function layoutMulti(g: Graph, comps: Graph[], globalRoot: Center, pinfo:
     layoutComponent(g, sg, globalRoot);
     finaliseCoords(sg);
   }
-  twopiCleanup(g); // ORDERING: before spline routing
+  twopiFreeAlg(g); // ORDERING: before spline routing
   packSubgraphs(comps.length, comps, g, pinfo);
   // C: spline_edges(g) — shifts pos to the origin, syncs coord, routes.
   splineEdgesShifted(g);

package/src/model/cgraph-ops.ts

@@ -26,6 +26,25 @@ import { Node } from './node.js';
  */
 const LOCALNAMEPREFIX = '%';
 
+/**
+ * cgraph's id for the first anonymous object, which an anonymous root graph is
+ * (agopen maps its NULL name first; idmap hands out odd ids from 1).
+ * @see lib/cgraph/id.c:idmap
+ */
+const ANONYMOUS_ROOT_ID = 1;
+
+/**
+ * Graph name as `agnameof` returns it: the DOT name, or `%<id>` for an
+ * anonymous graph. The port stores `''` for an anonymous root (dot/xdot
+ * re-serialization must not print the `%` name), so it is restored here.
+ * Anonymous subgraph ids are not tracked; callers pass the root, as C's
+ * neato message sites do.
+ * @see lib/cgraph/id.c:agnameof
+ */
+export function agNameOf(g: Graph): string {
+  return g.anonymous ? `${LOCALNAMEPREFIX}${ANONYMOUS_ROOT_ID}` : g.name;
+}
+
 /**
  * Allocate a fresh node id unique within `root.nodes`. Mirrors C's
  * agnextseq/agmapnametoid id reservation: at layout time the per-parse

package/src/render/color-resolve.ts

@@ -27,7 +27,7 @@ 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 { findStopColor, styleTokensQuiet } from '../common/style-resolve.js';
 import { emitOnce } from '../common/emit-once.js';
 
 /**
@@ -122,6 +122,21 @@ export function firstColor(name: string): string {
  */
 export function resolveRenderColor(raw: string, report = true): GVColor {
   if (raw === '' || raw === 'none') return { type: 'none' };
+  return resolveColorName(raw, report);
+}
+
+/**
+ * {@link resolveRenderColor} without the empty-name shortcut: C hands an empty
+ * name (a leading ':' cut at the first colon) to colorxlate, which rejects it
+ * (`Warning:  is not a known color.`) and leaves opaque black.
+ * @see lib/gvc/gvrender.c:456 gvrender_set_fillcolor
+ */
+export function resolveFillColorName(raw: string, report = true): GVColor {
+  if (raw === 'none') return { type: 'none' };
+  return resolveColorName(raw, report);
+}
+
+function resolveColorName(raw: string, report: boolean): GVColor {
   // C keeps a known name verbatim (case preserved); only the compare is
   // case-insensitive (bsearch over a lowercase table).
   const known = KNOWN_COLORS.has(raw.toLowerCase());
@@ -338,7 +353,7 @@ export function reportEdgeColors(e: Edge): void {
   reportColorNames(edgeGraphicsColors({
     color,
     fillcolor: e.attrs.get('fillcolor') ?? '',
-    tapered: styleTokens(e.attrs.get('style')).includes('tapered'),
+    tapered: styleTokensQuiet(e.attrs.get('style')).includes('tapered'),
     arrows: spl.list.map((bz) => ({ sflag: bz.sflag !== 0, eflag: bz.eflag !== 0 })),
   }));
 }

package/src/render/json.ts

@@ -239,12 +239,8 @@ function applyDraws(attrs: Map<string, string> | undefined, d: XdotDraws | undef
  *  hand-built graph with no real layout state) so callers fall back cleanly. */
 function collectDrawLookup(g: Graph): DrawLookup | undefined {
   let xg: Graph;
-  // Inject our own XdotRenderer (last-registered wins bestRenderer) so we can
-  // read its per-object draw strings AFTER the render: the DOT-text re-parse
-  // below is faithful for coordinates but LOSSY for draw text containing `"`
-  // (a DOT quoted string cannot hold `\` before `"`; a cluster label's `\"`
-  // round-trips to `"`, id 2239). The draws map holds the pre-serialization
-  // strings C's -Tjson reads directly, so we overlay them onto the re-parse.
+  // Our own XdotRenderer (last-registered wins) exposes raw draw strings: the
+  // DOT re-parse is LOSSY for draw text containing `"` (id 2239); overlay them.
   const xr = new XdotRenderer();
   try {
     const ctx = createDefaultContext();
@@ -650,8 +646,8 @@ function latin1Reencode(s: string): string {
   return out;
 }
 
-export function buildJson(g: Graph, doXDot: boolean): string {
-  const draws = doXDot ? collectDrawLookup(g) : undefined;
+export function buildJson(g: Graph, doXDot: boolean, preDraws?: DrawLookup): string {
+  const draws = doXDot ? (preDraws ?? collectDrawLookup(g)) : undefined;
   const ctx = assignIds(g, doXDot, draws);
   const root = buildGraphObject(g, true, ctx);
   return JSON.stringify(root, null, 2) + '\n';
@@ -702,10 +698,13 @@ export class JsonRenderer implements RendererPlugin {
   /** @see plugin/core/gvplugin_core.c registration table */
   readonly quality = 0;
 
-  beginGraph(_g: Graph, _job: RenderJob): void { /* no-op */ }
+  private draws: DrawLookup | undefined; // set by beginGraph, cleared by endGraph
+  /** @see plugin/core/gvrender_core_json.c:json_begin_graph */
+  beginGraph(g: Graph, _job: RenderJob): void { this.draws = collectDrawLookup(g); }
 
   endGraph(g: Graph, job: RenderJob): void {
-    job.write(buildJson(g, true));
+    job.write(buildJson(g, true, this.draws));
+    this.draws = undefined;
   }
 
   beginNode(_n: Node, _job: RenderJob): void { /* no-op */ }

package/src/render/map.ts

@@ -11,6 +11,7 @@
  */
 
 import type { Graph } from '../model/graph.js';
+import { agNameOf } from '../model/cgraph-ops.js';
 import type { Node } from '../model/node.js';
 import type { Edge } from '../model/edge.js';
 import type { Point, Box } from '../model/geom.js';
@@ -583,13 +584,11 @@ export class PlainExtRenderer implements RendererPlugin {
 // Imagemap renderers (cmapx / imap and their no-polygon `_np` variants)
 // ---------------------------------------------------------------------------
 
-/** Graph name as `agnameof` returns it: the DOT name, or `%1` for an anonymous
- * root (cgraph's first anonymous id). The port stores `''` for an anonymous
- * root (dot/xdot re-serialization must not print a `%`-name — see dot.ts), so
- * the imagemap layer restores the internal name only here.
- * @see lib/cgraph/id.c:agnameof ; lib/cgraph/id.c:idmap (anon → `%1`) */
+/** Graph name as `agnameof` returns it (`%1` for an anonymous root; the port
+ * stores `''` there so dot/xdot re-serialization stays unchanged).
+ * @see lib/cgraph/id.c:agnameof */
 export function mapGraphName(g: Graph): string {
-  return g.anonymous ? '%1' : g.name;
+  return agNameOf(g);
 }
 
 /** First non-empty attr walking parent scopes (agget inheritance). */