@knowvah/dot-engine 2.7.0 → 2.8.0

package/src/common/poly-sizing.ts

@@ -89,6 +89,7 @@ export interface PolySizeParams {
    * @see lib/common/shapes.c:2132-2145
    */
   nojustify?: boolean;
+  imageSize?: Point; // padded image size in points, shapes.c:2020-2051 imagesize
 }
 
 /** Node geometry in points: left/right half-widths and height. */
@@ -550,7 +551,8 @@ export function polySize(p: PolySizeParams): PolySizeResult {
   const init = initialSizePts(p);
   const dimen = quantize(padLabelDimen(p.labelDimen, p.margin, p.isPlain), p.quantumIn);
   const { sides, isBox } = effectiveShape(p);
-  let bb: Point = { x: dimen.x, y: dimen.y };
+  const img = p.imageSize ?? { x: 0, y: 0 }; // shapes.c:2055: bb = max(dimen, imagesize)
+  let bb: Point = { x: Math.max(dimen.x, img.x), y: Math.max(dimen.y, img.y) };
   // C shapes.c:2073-2085 dispatch: box → exact fit; poly_desc shapes (star,
   // cylinder) → their size_gen; everything else → generic ellipse fit.
   if (isBox) {
@@ -583,8 +585,6 @@ export function polySize(p: PolySizeParams): PolySizeResult {
  * Compute the label's justification borders (ND_label->space) and vertical
  * alignment — the "space available for label" block of poly_init. `bb` is the
  * final (constrained) box; `minBb` is the pre-constraint shape-fit box.
- * Image sizing is unported, so `imagesize` is 0 (which matches C for the
- * missing-image repro cases); revisit when image loading lands.
  * @see lib/common/shapes.c:poly_init (2132-2152)
  */
 function labelSpace(
@@ -604,7 +604,7 @@ function labelSpace(
     spaceX = dimen.x - spacex;
   }
   // space.y: !fixedshape → dimen.y + (bb.y - min_bb.y); fixedshape keeps dimen.y.
-  const spaceY = fixedshape ? dimen.y : dimen.y + (bb.y - minBb.y);
+  const spaceY = fixedshape ? dimen.y : dimen.y + ((bb.y - minBb.y) + Math.max(0, (p.imageSize?.y ?? 0) - dimen.y));
   return { space: { x: spaceX, y: spaceY }, valign: labelValign(p) };
 }
 

package/src/common/postproc.ts

@@ -27,6 +27,7 @@ import {
 } from '../layout/dot/init.js';
 import { addXLabels } from './xlabels-place.js';
 import { registerRenderState } from './render-state.js';
+import { getState, GVSPLINES } from './layout-state.js';
 import { agerrorf } from './agerr.js';
 
 /** Concentrated multi-edge duplicate — never drawn. @see lib/common/const.h:IGNORED */
@@ -221,7 +222,9 @@ function translateDrawing(g: Graph): void {
 
   for (const v of g.nodes.values()) {
     mapNode(v);
-    // State == GVSPLINES is always true post-spline-routing in the dot pipeline
+    // C: `if (State == GVSPLINES)` guards the whole edge loop; layouts that
+    // never route (patchwork, osage) leave State at GVBEGIN.
+    if (getState() !== GVSPLINES) continue;
     for (const e of g.edges) {
       if (e.tail !== v) continue;
       // C map_edge: a spline-less (non-concentrate, non-IGNORED) edge was

package/src/common/style-resolve.ts

@@ -22,8 +22,9 @@
  */
 
 import { PenType } from '../gvc/context.js';
+import { agerrorf, agwarningf } from './agerr.js';
 import { parseGradientSpec } from './htmltable-emit-fill.js';
-import { parseSegs } from './multicolor.js';
+import { MSG_MANY_COLORS, parseSegs } from './multicolor.js';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -156,28 +157,113 @@ function zeroFlags(): PolyStyleFlags {
   };
 }
 
-/** C parse_style truncates the style list at FUNLIMIT tokens. @see lib/common/emit.c:4001 */
+/** C parse_style truncates the style list at FUNLIMIT tokens. @see lib/common/emit.c:3998 FUNLIMIT */
 const FUNLIMIT = 64;
 
+/** Characters `gv_isspace` accepts. @see lib/cgraph/gv_ctype.h:gv_isspace */
+const STYLE_SPACE: ReadonlySet<string> = new Set([' ', '\t', '\n', '\v', '\f', '\r']);
+
+/** @see lib/common/emit.c:3949 is_style_delim ('\0' is the end of the C string) */
+function isStyleDelim(c: string | undefined): boolean {
+  return c === undefined || c === '(' || c === ')' || c === ',';
+}
+
+/** One `style_token` result: `(`, `)`, an identifier, or the end (`null`). */
+interface StyleToken {
+  readonly type: '(' | ')' | 'id';
+  readonly text: string;
+  /** Index in the style string just past the token. */
+  readonly next: number;
+}
+
+/**
+ * Skips spaces and commas, then reads one token: a parenthesis, or everything
+ * up to the next delimiter (trailing spaces included). Null at the end.
+ * @see lib/common/emit.c:3974 style_token
+ */
+function styleToken(s: string, from: number): StyleToken | null {
+  let p = from;
+  while (p < s.length && (STYLE_SPACE.has(s[p]) || s[p] === ',')) p++;
+  if (p >= s.length) return null;
+  if (s[p] === '(' || s[p] === ')') return { type: s[p] as '(' | ')', text: s[p], next: p + 1 };
+  const start = p;
+  while (!isStyleDelim(s[p])) p++;
+  return { type: 'id', text: s.slice(start, p), next: p };
+}
+
+/** Why `parseStyle` produced an empty list, or null when it did not. */
+type StyleFault = 'nesting' | 'unmatched-close' | 'unmatched-open' | 'truncate';
+
+/** Result of the tokenizer: the list (empty on a fault) and the fault, if any. */
+interface StyleParse {
+  readonly tokens: string[];
+  readonly fault: StyleFault | null;
+}
+
+const NO_TOKENS: StyleParse['tokens'] = [];
+
 /**
- * The raw style tokens C's parse_style produces (comma-separated, trimmed,
- * non-empty), truncated to empty past FUNLIMIT. These are what xdot's
- * `xdot_style` re-emits as `S` ops (it skips filled/bold/setlinewidth). The
- * port resolves style into a PenType for SVG; xdot needs the original tokens.
+ * parse_style without the diagnostics. A token's `(args)` are appended to it,
+ * as C stores them after the token's NUL: `setlinewidth( 2 )` → `setlinewidth(2 )`.
+ * @see lib/common/emit.c:4010 parse_style
+ */
+function parseStyleQuiet(s: string): StyleParse {
+  const end = s.indexOf('\0');
+  const str = end < 0 ? s : s.slice(0, end);
+  const names: string[] = [];
+  const args: string[][] = [];
+  let inParens = false;
+  for (let c = styleToken(str, 0); c !== null; c = styleToken(str, c.next)) {
+    if (c.type === '(') {
+      if (inParens) return { tokens: NO_TOKENS, fault: 'nesting' };
+      inParens = true;
+    } else if (c.type === ')') {
+      if (!inParens) return { tokens: NO_TOKENS, fault: 'unmatched-close' };
+      inParens = false;
+    } else if (inParens) {
+      args[names.length - 1]?.push(c.text);
+    } else {
+      if (names.length === FUNLIMIT - 1) return { tokens: NO_TOKENS, fault: 'truncate' };
+      names.push(c.text);
+      args.push([]);
+    }
+  }
+  if (inParens) return { tokens: NO_TOKENS, fault: 'unmatched-open' };
+  const tokens = names.map((n, i) => (args[i].length === 0 ? n : `${n}(${args[i].join(',')})`));
+  return { tokens, fault: null };
+}
+
+/** The agerr line for a fault, byte for byte. @see lib/common/emit.c:4027-4062 */
+function reportStyleFault(fault: StyleFault, s: string): void {
+  if (fault === 'nesting') agerrorf(`nesting not allowed in style: ${s}`);
+  else if (fault === 'unmatched-close') agerrorf(`unmatched ')' in style: ${s}`);
+  else if (fault === 'unmatched-open') agerrorf(`unmatched '(' in style: ${s}`);
+  else agwarningf(`truncating style '${s}'`);
+}
+
+/**
+ * The raw style tokens C's `parse_style` produces, untrimmed, `(args)`
+ * attached; empty on a fault, which it reports (agerr) on every call. These
+ * are what xdot's `xdot_style` re-emits as `S` ops. Call it where C calls
+ * `parse_style`; use `styleTokensQuiet` to read a list C has already parsed.
  * @see lib/common/emit.c:4010 parse_style · gvrender_core_dot.c:161 xdot_style
  */
 export function styleTokens(style: string | undefined): string[] {
   if (!style) return [];
-  const out: string[] = [];
-  let fun = 0;
-  for (const raw of style.split(',')) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return [];
-    fun++;
-    out.push(token);
-  }
-  return out;
+  const { tokens, fault } = parseStyleQuiet(style);
+  if (fault !== null) reportStyleFault(fault, style);
+  return tokens;
+}
+
+/** `styleTokens` without the diagnostics, for re-reads of a style C parsed once. */
+export function styleTokensQuiet(style: string | undefined): string[] {
+  return style ? parseStyleQuiet(style).tokens : [];
+}
+
+/** The name C compares: parse_style stores a token's `(args)` after its NUL. */
+export function styleName(token: string): string {
+  const paren = token.indexOf('(');
+  return paren < 0 ? token : token.slice(0, paren);
 }
 
 /**
@@ -187,9 +273,9 @@ export function styleTokens(style: string | undefined): string[] {
  * @see lib/gvc/gvrender.c:501
  */
 function parseSetLineWidth(token: string): number | null {
-  const m = /^setlinewidth\s*\(\s*([^)]*)\)\s*$/.exec(token);
-  if (m === null) return null;
-  const v = parseFloat(m[1]);
+  if (styleName(token) !== 'setlinewidth') return null;
+  const m = /^[^(]*\(([^,)]*)/.exec(token);
+  const v = m === null ? Number.NaN : parseFloat(m[1]);
   return Number.isNaN(v) ? 0 : v;
 }
 
@@ -227,29 +313,19 @@ function firstSolidColor(raw: string): string {
 /**
  * Parse a graphviz style attribute string into a flag set.
  *
- * Splits on commas and trims. A `setlinewidth(N)` token captures its pen-width
- * argument; other tokens containing '(' are ignored. When the non-empty token
- * count reaches FUNLIMIT (64), C's parse_style returns early before building
- * the style list — the observable effect is an empty style list (no flags
- * applied), which we reproduce by returning zeroFlags().
+ * Tokenizes like C's parse_style (untrimmed tokens, empty list on a fault) and
+ * reports nothing: C's callers parse once and reuse the list. A
+ * `setlinewidth(N)` token captures its pen-width argument.
  *
  * @see lib/common/emit.c:4010 parse_style (FUNLIMIT truncation)
  * @see lib/gvc/gvrender.c:481 gvrender_set_style (setlinewidth → penwidth)
  */
 export function parseStyleFlags(style: string | undefined): PolyStyleFlags {
   const flags = zeroFlags();
-  if (!style) return flags;
-  let fun = 0;
-  for (const raw of style.split(',')) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    // C truncates at the FUNLIMIT-th token, skipping the pointer-construction
-    // loop → the returned list is empty → no flags apply.
-    if (fun === FUNLIMIT - 1) return zeroFlags();
-    fun++;
+  for (const token of styleTokensQuiet(style)) {
     const lw = parseSetLineWidth(token);
     if (lw !== null) { flags.setLineWidth = lw; continue; }
-    if (!token.includes('(')) applyToken(flags, token);
+    applyToken(flags, styleName(token));
   }
   return flags;
 }
@@ -274,16 +350,7 @@ export function parseStyleFlags(style: string | undefined): PolyStyleFlags {
  * @see lib/common/shapes.c:point_gencode (point_style whitelist)
  */
 export function styleHasInvisibleAlias(style: string | undefined): boolean {
-  if (!style) return false;
-  let fun = 0;
-  for (const raw of style.split(',')) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return false;
-    fun++;
-    if (token === 'invisible') return true;
-  }
-  return false;
+  return styleTokensQuiet(style).some((token) => styleName(token) === 'invisible');
 }
 
 export function resolvePenType(flags: PolyStyleFlags): PenType {
@@ -418,11 +485,10 @@ export function findStopColor(
   colorlist: string,
 ): { fillColor: string; stopColor: string; frac: number } | null {
   const { segs, error } = parseSegs(colorlist);
-  if (error === 1 || error === 2) return null;
-  if (segs.length < 2) return null;
-  const seg0 = segs[0]!;
-  const seg1 = segs[1]!;
-  if (seg0.color === null) return null;
+  const seg0 = segs[0];
+  const seg1 = segs[1];
+  if (error !== 0 || seg0 === undefined || seg1 === undefined || seg0.color === null) return null;
+  if (segs.length > 2) agwarningf(MSG_MANY_COLORS);
   const fillColor = seg0.color;
   const stopColor = seg1.color ?? DEFAULT_COLOR;
   const frac = seg0.hasFraction ? seg0.t
@@ -445,7 +511,9 @@ function buildResolvedFill(
   angle: number,
 ): ResolvedFill {
   const stop = findStopColor(rawColor);
-  if (stop === null) return { kind: 'solid', color: rawColor };
+  // gvrender_set_fillcolor cuts a colour list at the first ':' (and so does the
+  // unknown-colour warning it can raise).
+  if (stop === null) return { kind: 'solid', color: rawColor.split(':', 1)[0]! };
   const kind = flags.radial ? 'radial' : 'linear';
   return { kind, fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle };
 }

package/src/gvc/device-cluster.ts

@@ -17,8 +17,9 @@ import {
   resolveClusterFillEx, styleTokens,
 } from '../common/style-resolve.js';
 import { gvrenderSetStyle, checkClusterStyleTokens } from './gvrender-set-style.js';
-import { resolveRenderColor, withColorScheme, reportColorNames } from '../render/color-resolve.js';
+import { resolveRenderColor, reportColorNames } from '../render/color-resolve.js';
 import { parseSegs } from '../common/multicolor.js';
+import { graphAttrInherited } from '../common/attr-get.js';
 
 /**
  * Copy gradient fields from a linear/radial ResolvedFill onto obj.
@@ -36,19 +37,14 @@ function applyClusterGradient(
 }
 
 /**
- * Read a cluster graph-attribute with ancestor inheritance (agxget): a cluster
- * with no value of its own inherits an ancestor's `graph[key=...]`. C resolves
- * every cluster attr this way (late_string(sg, agfindgraphattr(sg, key), ...)),
- * so a root-level style/color/pencolor/fillcolor/bgcolor/penwidth/gradientangle
- * applies to the cluster boundary as the oracle does.
- * @see lib/common/emit.c:emit_clusters (cluster attrs via agxget)
+ * Read a cluster graph-attribute as C's `agget(sg, key)` does: the cluster's
+ * own value, else the ancestor defaults snapshotted when `agsubg` opened it.
+ * A root `graph[key=...]` declared after the cluster is NOT seen (item 89).
+ * @see lib/cgraph/graph.c:agsubg
+ * @see lib/common/emit.c:emit_clusters (cluster attrs via agget/agxget)
  */
 export function clusterAttr(sg: Graph, key: string): string | undefined {
-  for (let g: Graph | null = sg; g !== null; g = g.parent) {
-    const v = g.attrs.get(key);
-    if (v !== undefined) return v;
-  }
-  return undefined;
+  return graphAttrInherited(sg, key);
 }
 
 /** Cluster `style` with ancestor inheritance. @see clusterAttr */
@@ -107,15 +103,13 @@ export function applyClusterObjState(sg: Graph, job: RenderJob): boolean {
   // 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);
-    reportColorNames(stripedClusterColors(sg));
-    return filled;
-  });
+  // Runs inside renderCluster's setColorScheme window. @see emit.c:3800/3943
+  // 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);
+  reportColorNames(stripedClusterColors(sg));
+  return filled;
 }
 
 /**
@@ -164,24 +158,22 @@ function stripedClusterColors(sg: Graph): string[] {
 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);
-  });
+  // stripedBox runs inside renderCluster's setColorScheme window (3800/3943).
+  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. */

package/src/gvc/device.ts

@@ -26,7 +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 { firstLayer, nextLayer, numPhysicalLayers, validLayer } from './first-layer.js';
 import { polyInit } from '../common/poly-init.js';
 import {
   setHtmlAnchorObj,
@@ -48,7 +48,7 @@ import {
   setRendererKnownColors,
 } from '../render/color-resolve.js';
 import { emitRoundedBezier } from '../common/poly-shapes.js';
-import { applyClusterObjState, clusterStyle, clusterPeripheries, isStripedCluster, renderStripedClusterBox } from './device-cluster.js';
+import { applyClusterObjState, clusterAttr, clusterStyle, clusterPeripheries, isStripedCluster, renderStripedClusterBox } from './device-cluster.js';
 import { transformPoint } from './device-transform.js';
 import { gvrenderSetStyle, edgeStyleResets } from './gvrender-set-style.js';
 import { renderOneLabel, renderNodeXLabel, renderClusterLabel, reportEdgeLabelColors } from './device-labels.js';
@@ -156,7 +156,7 @@ export function renderNode(n: Node, renderer: RendererPlugin, job: RenderJob, do
  * Set the edge pen color/type/width on job.obj from the edge's attrs — mirrors
  * emit_edge_graphics. (AD1: style flows through job.obj, not ad-hoc renderer reads.)
  */
-function setEdgePen(e: Edge, job: RenderJob): void {
+function setEdgePen(e: Edge, job: RenderJob, styles: readonly string[]): void {
   if (job.obj === null) return;
   const obj = job.obj;
   const flags = parseStyleFlags(e.attrs.get('style'));
@@ -166,7 +166,7 @@ function setEdgePen(e: Edge, job: RenderJob): void {
   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'));
+  obj.rawStyle = [...styles];
   // 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);
@@ -178,13 +178,16 @@ export function renderEdge(e: Edge, renderer: RendererPlugin, job: RenderJob): v
   // before emit_begin_edge. @see lib/common/emit.c:emit_edge (style "invis" return)
   // The "invisible" alias likewise suppresses all edge draw ops via PEN_NONE
   // (edges never use the point-shape whitelist). @see lib/gvc/gvrender.c:497
+  // emit_edge parses the style once (reporting its faults); the rest reuse the list.
+  // @see lib/common/emit.c:2013 emit_edge
   const edgeStyle = e.attrs.get('style');
+  const styles = styleTokens(edgeStyle);
   if (parseStyleFlags(edgeStyle).invis || styleHasInvisibleAlias(edgeStyle)) return;
   // push_obj_state in emit_begin_edge (line 2715)
   const obj = createObjState(ObjType.Edge);
   obj.emitState = EmitState.EDraw;
   job.pushObj(obj);
-  setEdgePen(e, job);
+  setEdgePen(e, job, styles);
   try {
     // @see lib/common/emit.c:emit_begin_edge / getObjId
     setHtmlAnchorObj(svgEdgeId(e, job), labelTextOf(e.info.label), job.obj ?? undefined);
@@ -202,7 +205,6 @@ export function renderEdge(e: Edge, renderer: RendererPlugin, job: RenderJob): v
       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);
@@ -252,6 +254,41 @@ function renderClusterBox(
   renderer.polygon(rawPts.map(p => transformPoint(p, job)), filled, job);
 }
 
+/**
+ * The body of emit_clusters between setColorScheme and its restore.
+ * @see lib/common/emit.c:3800-3943 emit_clusters
+ */
+function drawClusterInScheme(sg: Graph, renderer: RendererPlugin, job: RenderJob): void {
+  // Resolve and wire cluster fill/pen into job.obj before the polygon.
+  // emit_clusters:3805-3874 — must happen before gvrender_box.
+  const filled = applyClusterObjState(sg, job);
+  // Cluster id is clust<AGSEQ seq> (getObjId); obj.id feeds emitGradientDefs
+  // the "clustN_l_0" gradient prefix. seq is stable on the subgraph, so the
+  // begin/assign order below is no longer load-bearing.
+  // @see lib/common/emit.c:209 getObjId (AGRAPH/cluster: pfx="clust")
+  renderer.beginCluster?.(sg, job);
+  if (job.obj !== null) job.obj.id = svgClusterId(sg, job);
+  // @see lib/common/emit.c:emit_begin_cluster / getObjId
+  setHtmlAnchorObj(svgClusterId(sg, job), labelTextOf(sg.info.label), job.obj ?? undefined);
+  // Resolve and open the cluster anchor around the box + label (closed before
+  // the cluster's child nodes — sibling of them). @see emit.c:3803.
+  if (job.obj !== null) {
+    resolveObjAnchor(sg, labelTextOf(sg.info.label), svgClusterId(sg, job), job.obj);
+  }
+  const anchored = beginAnchorIf(renderer, job);
+  // C draws the boundary box only when peripheries != 0, or (peripheries == 0
+  // and the cluster is filled). peripheries=0 + unfilled emits nothing.
+  // 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 || isStripedCluster(sg)) && job.obj?.pen !== PenType.None) {
+    renderClusterBox(sg, filled, renderer, job);
+  }
+  renderClusterLabel(sg, renderer, job);
+  if (anchored) renderer.endAnchor?.(job);
+  renderer.endCluster?.(sg, job);
+}
+
 /**
  * Render one cluster: box, label, endCluster, then recurse into sub-clusters.
  * push_obj_state in emit_begin_cluster (3762); pop in emit_end_cluster (3774).
@@ -271,34 +308,10 @@ function renderOneCluster(sg: Graph, renderer: RendererPlugin, job: RenderJob):
   obj.emitState = EmitState.CDraw;
   job.pushObj(obj);
   try {
-    // Resolve and wire cluster fill/pen into job.obj before the polygon.
-    // emit_clusters:3805-3874 — must happen before gvrender_box.
-    const filled = applyClusterObjState(sg, job);
-    // Cluster id is clust<AGSEQ seq> (getObjId); obj.id feeds emitGradientDefs
-    // the "clustN_l_0" gradient prefix. seq is stable on the subgraph, so the
-    // begin/assign order below is no longer load-bearing.
-    // @see lib/common/emit.c:209 getObjId (AGRAPH/cluster: pfx="clust")
-    renderer.beginCluster?.(sg, job);
-    if (job.obj !== null) job.obj.id = svgClusterId(sg, job);
-    // @see lib/common/emit.c:emit_begin_cluster / getObjId
-    setHtmlAnchorObj(svgClusterId(sg, job), labelTextOf(sg.info.label), job.obj ?? undefined);
-    // Resolve and open the cluster anchor around the box + label (closed before
-    // the cluster's child nodes — sibling of them). @see emit.c:3803.
-    if (job.obj !== null) {
-      resolveObjAnchor(sg, labelTextOf(sg.info.label), svgClusterId(sg, job), job.obj);
-    }
-    const anchored = beginAnchorIf(renderer, job);
-    // C draws the boundary box only when peripheries != 0, or (peripheries == 0
-    // and the cluster is filled). peripheries=0 + unfilled emits nothing.
-    // 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 || isStripedCluster(sg)) && job.obj?.pen !== PenType.None) {
-      renderClusterBox(sg, filled, renderer, job);
-    }
-    renderClusterLabel(sg, renderer, job);
-    if (anchored) renderer.endAnchor?.(job);
-    renderer.endCluster?.(sg, job);
+    // C opens setColorScheme right after emit_begin_cluster and restores it after
+    // emit_label(EMIT_CLABEL): the window spans fill, pen, box and label.
+    // @see lib/common/emit.c:3800 / :3943 emit_clusters
+    withColorScheme(clusterAttr(sg, 'colorscheme'), () => drawClusterInScheme(sg, renderer, job));
   } finally {
     // pop_obj_state in emit_end_cluster (line 3774), before sub-cluster recursion
     job.popObj();
@@ -341,18 +354,17 @@ export function renderGraph(g: Graph, job: RenderJob, renderer: RendererPlugin):
   job.pushObj(obj);
   try {
     const info = parseLayers(g);
-    // Only layer-capable renderers (SVG) do the layer loop; others collapse to
-    // one pass. @see lib/common/emit.c:1140 (GVDEVICE_DOES_LAYERS)
-    const layered = renderer.beginLayer !== undefined && info.numLayers > 1;
-    job.numLayers = layered ? info.numLayers : 1;
+    // emit_graph sets job->layerNum = 0 before emit_begin_graph.
+    job.layerNum = 0;
     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);
+    const cur = firstLayer(job, info, renderer.beginLayer !== undefined);
+    for (; validLayer(job); nextLayer(job, cur)) {
+      const layered = numPhysicalLayers(job, info) > 1;
+      // gvrender_begin_layer/end_layer are no-ops without a plugin callback.
+      if (layered) renderer.beginLayer?.(info.layerIDs[job.layerNum]!, job);
       renderPage(g, renderer, job, info);
-      if (layered) renderer.endLayer!(job);
+      if (layered) renderer.endLayer?.(job);
     }
     renderer.endGraph(g, job);
   } finally {

package/src/gvc/first-layer.ts

@@ -1,11 +1,13 @@
 // 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.
+ * The layer walk of `emit_graph`: `for (firstlayer; validlayer; nextlayer)`
+ * over either every layer or the `layerselect` list, plus the
+ * `GVDEVICE_DOES_LAYERS` warning. `GVDEVICE_DOES_LAYERS` is
+ * `renderer.beginLayer !== undefined`.
  */
 import { agwarningf } from '../common/agerr.js';
+import type { LayerInfo } from '../common/layers.js';
+import type { RenderJob } from './job.js';
 
 /** Port format ids that spell a native `-T` name differently (`output_langname`). */
 const NATIVE_LANGNAME: ReadonlyMap<string, string> = new Map([
@@ -13,14 +15,61 @@ const NATIVE_LANGNAME: ReadonlyMap<string, string> = new Map([
   ['imap-np', 'imap_np'],
 ]);
 
+/** C's `int **listp`: the selected-layer list and the read position in it. */
+export interface LayerCursor {
+  list: number[] | null;
+  pos: number;
+}
+
+function warnUnsupported(job: RenderJob): void {
+  agwarningf(`layers not supported in ${NATIVE_LANGNAME.get(job.format) ?? job.format} output`);
+}
+
+/**
+ * Number of layers emitted (begin/end layer wrap them only when above one).
+ * @see lib/common/emit.c:numPhysicalLayers
+ */
+export function numPhysicalLayers(job: RenderJob, info: LayerInfo): number {
+  return info.layerList !== null ? info.layerList[0]! : job.numLayers;
+}
+
 /**
- * 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.
+ * 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. With a list, a device without layers keeps only the
+ * first entry by overwriting the second with the sentinel (as C does, in place).
  * @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`);
+export function firstLayer(job: RenderJob, info: LayerInfo, doesLayers: boolean): LayerCursor {
+  job.numLayers = info.numLayers;
+  const list = info.layerList;
+  if (list !== null) {
+    if (list[0]! > 1 && !doesLayers) {
+      warnUnsupported(job);
+      list[2] = job.numLayers + 1; // only one layer printed
+    }
+    job.layerNum = list[1]!;
+    return { list, pos: 2 };
+  }
+  if (job.numLayers > 1 && !doesLayers) {
+    warnUnsupported(job);
+    job.numLayers = 1;
+  }
+  job.layerNum = 1;
+  return { list: null, pos: 0 };
+}
+
+/** @see lib/common/emit.c:validlayer */
+export function validLayer(job: RenderJob): boolean {
+  return job.layerNum <= job.numLayers;
+}
+
+/** @see lib/common/emit.c:nextlayer */
+export function nextLayer(job: RenderJob, cur: LayerCursor): void {
+  if (cur.list !== null) {
+    job.layerNum = cur.list[cur.pos]!;
+    cur.pos++;
+  } else {
+    job.layerNum++;
+  }
 }