@knowvah/dot-engine 2.6.12 → 2.7.0

package/src/common/multicolor.ts

@@ -13,6 +13,10 @@
  * @see lib/common/emit.c:470 parseSegs
  */
 
+import { agerr, agerrorf, agwarningf } from './agerr.js';
+import type { Edge } from '../model/edge.js';
+import { registerRenderState } from './render-state.js';
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -38,6 +42,28 @@ export interface ColorSeg {
 // Constants
 // ---------------------------------------------------------------------------
 
+/**
+ * C's `static atomic_flag warned` in parseSegs: set by the first Total-size
+ * warning or Illegal-value error in the process, silencing both afterwards.
+ * Reset per render (AD-4).
+ * @see lib/common/emit.c:470 parseSegs
+ */
+const parseSegsState = { warned: false };
+
+registerRenderState(() => {
+  parseSegsState.warned = false;
+});
+
+/** `atomic_flag_test_and_set(&warned)` negated: true when this call claimed it. */
+function claimWarned(): boolean {
+  if (parseSegsState.warned) return false;
+  parseSegsState.warned = true;
+  return true;
+}
+
+/** A claim that never fires: parses without touching or consuming the flag. */
+const claimNever = (): boolean => false;
+
 /** @see lib/common/emit.c:451 EPS */
 const EPS = 1e-5;
 
@@ -76,7 +102,7 @@ function appendSeg(
   token: string,
   left: number,
   segs: ColorSeg[],
-  warnedExceeded: { v: boolean },
+  claim: () => boolean,
 ): { left: number; rval: 0 | 3 } | null {
   const { color, v } = getSegLen(token);
   if (v < 0) return null;
@@ -85,10 +111,7 @@ function appendSeg(
   let rval: 0 | 3 = 0;
   const del = t - left;
   if (del > 0) {
-    if (!aeq0(del) && !warnedExceeded.v) {
-      warnedExceeded.v = true;
-      rval = 3;
-    }
+    if (!aeq0(del) && claim()) rval = 3;
     t = left;
   }
   left -= t;
@@ -128,34 +151,20 @@ function trimTrailing(segs: ColorSeg[]): void {
 // ---------------------------------------------------------------------------
 
 /**
- * Parse `"c1;f1:c2;f2:…"` into segments.
- *
- * Fractions are optional and non-negative; their sum must not exceed 1.
- * Segments without an explicit fraction share the remaining weight equally;
- * if none exist the remainder is added to the last segment.
- *
- * Return codes (mirror C):
- *   0 → ok; 1 → silent error; 2 → error with message; 3 → warning (sum > 1).
- * On rv 1 or 2 the returned segs array is empty.
- *
+ * The parse of `parseSegs` with the once-per-process flag abstracted as `claim`.
  * @see lib/common/emit.c:470 parseSegs
  */
-export function parseSegs(
+function scanSegs(
   colorlist: string,
+  claim: () => boolean,
 ): { segs: ColorSeg[]; error: 0 | 1 | 2 | 3 } {
   const segs: ColorSeg[] = [];
   let left = 1;
   let rval: 0 | 3 = 0;
-  let badFloatCount = 0;
-  const warnedExceeded = { v: false };
 
   for (const token of colorlist.split(':')) {
-    const result = appendSeg(token, left, segs, warnedExceeded);
-    if (result === null) {
-      const errCode: 1 | 2 = badFloatCount === 0 ? 2 : 1;
-      badFloatCount++;
-      return { segs: [], error: errCode };
-    }
+    const result = appendSeg(token, left, segs, claim);
+    if (result === null) return { segs: [], error: claim() ? 2 : 1 };
     if (result.rval === 3) rval = 3;
     left = result.left;
     if (aeq0(left)) { left = 0; break; }
@@ -165,3 +174,58 @@ export function parseSegs(
   trimTrailing(segs);
   return { segs, error: rval };
 }
+
+/**
+ * Parse `"c1;f1:c2;f2:…"` into segments.
+ *
+ * Fractions are optional and non-negative; their sum must not exceed 1.
+ * Segments without an explicit fraction share the remaining weight equally;
+ * if none exist the remainder is added to the last segment.
+ *
+ * Return codes (mirror C):
+ *   0 → ok; 1 → silent error; 2 → error with message; 3 → warning (sum > 1).
+ * On rv 1 or 2 the returned segs array is empty.
+ *
+ * The rv 2 error and rv 3 warning are printed here, once per process (the
+ * shared `warned` flag). C's callers then append an AGPREV line for rv > 1;
+ * `context` supplies it (e.g. `in edge a -> b`): the warning continues the
+ * same line as C's AGPREV does, the error's context follows on its own line.
+ *
+ * @see lib/common/emit.c:470 parseSegs
+ */
+export function parseSegs(
+  colorlist: string,
+  context?: () => string,
+): { segs: ColorSeg[]; error: 0 | 1 | 2 | 3 } {
+  const result = scanSegs(colorlist, claimWarned);
+  if (result.error === 3) {
+    const tail = context === undefined ? '' : context();
+    agwarningf(`Total size > 1 in "${colorlist}" color spec ${tail}`);
+  } else if (result.error === 2) {
+    agerrorf(`Illegal value in "${colorlist}" color attribute; float expected after ';'`);
+    if (context !== undefined) agerr('prev', context());
+  }
+  return result;
+}
+
+/**
+ * {@link parseSegs} for port-internal re-parses that have no C counterpart
+ * call (pre-passes, parallel edges): same segments and error class, but never
+ * prints and never consumes the once-per-process flag.
+ */
+export function parseSegsSilent(
+  colorlist: string,
+): { segs: ColorSeg[]; error: 0 | 1 | 2 | 3 } {
+  return scanSegs(colorlist, claimNever);
+}
+
+/**
+ * The AGPREV line C's `multicolor` appends for an rv > 1 parseSegs.
+ * @see lib/common/emit.c:1985 multicolor
+ */
+export function edgeSegsContext(e: Edge): () => string {
+  return () => {
+    const directed = !e.tail.root.kind.endsWith('undirected');
+    return `in edge ${e.tail.name}${directed ? ' -> ' : ' -- '}${e.head.name}`;
+  };
+}

package/src/common/poly-gencode.ts

@@ -22,6 +22,7 @@ import { FillType } from '../gvc/context.js';
 import { emitHtmlLabel } from './htmltable-emit.js';
 import { transformPoint } from '../gvc/device.js';
 import { nodeAttr } from './poly-init.js';
+import { gvrenderSetStyle, checkStyleTokens } from '../gvc/gvrender-set-style.js';
 import { substObjAnchor, preprocessTooltip } from './subst.js';
 import type { ResolvedFill, PolyStyleFlags } from './style-resolve.js';
 import {
@@ -96,6 +97,7 @@ interface RingCtx {
   job: RenderJob;
   style: PolyStyleFlags;
   fillcolor: string;
+  nodeName: string; // agnameof(n): the `in node %s` AGPREV of a parseSegs rv > 1
   shape: number;
   diagonals: boolean;
   rounded: boolean;
@@ -114,7 +116,7 @@ function renderEllipseRing(
     const pf = ring.map(
       (v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job),
     );
-    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer);
+    wedgedEllipse(ctx.job, pf, ctx.fillcolor, ctx.renderer, () => `in node ${ctx.nodeName}`);
     renderEllipse(ring, coord, ctx.renderer, ctx.job, false); // boundary unfilled
   } else {
     renderEllipse(ring, coord, ctx.renderer, ctx.job, filled);
@@ -124,14 +126,12 @@ function renderEllipseRing(
 }
 
 /**
- * Render one polygon periphery ring, dispatching to stripedBox when
- * style.striped + j==0.
+ * Striped j===0 ring: the multicolor box plus an unfilled boundary polygon.
  * @see lib/common/shapes.c:poly_gencode :3037-3043
  */
-/** Striped j===0 ring: the multicolor box plus an unfilled boundary polygon. */
 function renderStripedRing(ring: Point[], coord: Point, ctx: RingCtx): void {
   const af = ring.map((v) => transformPoint({ x: v.x + coord.x, y: v.y + coord.y }, ctx.job));
-  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer);
+  stripedBox(ctx.job, af, ctx.fillcolor, true, ctx.renderer, () => `in node ${ctx.nodeName}`);
   renderPolygon(ring, coord, ctx.renderer, ctx.job, false); // boundary unfilled
 }
 
@@ -367,6 +367,13 @@ function applyPenState(obj: ObjState, styleAttr: string | undefined,
 export function applyNodeStyle(obj: ObjState, n: Node, job: RenderJob): boolean {
   const styleAttr = nodeAttr(n, n.root, 'style');
   const colorAttr = nodeAttr(n, n.root, 'color');
+  // stylenode: gvrender_set_style(job, checkStyle list), before any colour is
+  // resolved; point_gencode passes its own fixed list instead (never unknown).
+  // @see lib/common/shapes.c:536 stylenode · :3257 point_gencode
+  if (!isPointNode(n)) {
+    const shape = n.info.shape as ShapeDesc | undefined;
+    gvrenderSetStyle(checkStyleTokens(styleTokens(styleAttr), shape?.polygon ?? null));
+  }
   // The node's `colorscheme` window is NOT opened here: C opens it once around
   // the whole node emission (emit_begin_node..emit_end_node), which covers both
   // this color block and the label textspans. Both callers of this function are
@@ -391,7 +398,8 @@ export function applyNodeStyle(obj: ObjState, n: Node, job: RenderJob): boolean
  */
 function prepareDrawPoly(poly: PolygonT, filled: boolean, obj: ObjState): PolygonT {
   if (poly.peripheries !== 0 || !filled) return poly;
-  obj.penColor = { type: 'string', s: 'transparent' };
+  // gvrender_set_pencolor resolves (and may report) the name like any other.
+  obj.penColor = resolveRenderColor('transparent');
   return { ...poly, peripheries: 1 };
 }
 
@@ -446,6 +454,7 @@ function resolveNodeDrawCtx(job: RenderJob, n: Node): NodeDrawCtx | null {
     job,
     style: styleFlags,
     fillcolor: nodeAttr(n, n.root, 'fillcolor') ?? '',
+    nodeName: n.name,
     ...specialCornerFlags(drawPoly.option, styleFlags),
   };
   return { poly: drawPoly, coord, filled, ringCtx };
@@ -467,8 +476,7 @@ function specialCornerFlags(
 }
 
 /**
- * Render node shape (polygon/ellipse) and label.
- * Shape codefn — called from walkNodes.
+ * Render node shape (polygon/ellipse) and label; shape codefn, from walkNodes.
  * @see lib/common/shapes.c:poly_gencode
  */
 export function polyGencode(rawJob: unknown, rawNode: unknown): void {

package/src/common/poly-init.ts

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

package/src/common/postproc.ts

@@ -27,7 +27,7 @@ import {
 } from '../layout/dot/init.js';
 import { addXLabels } from './xlabels-place.js';
 import { registerRenderState } from './render-state.js';
-import { agerrLineOn } from './agerr.js';
+import { agerrorf } from './agerr.js';
 
 /** Concentrated multi-edge duplicate — never drawn. @see lib/common/const.h:IGNORED */
 const IGNORED_EDGE = 6;
@@ -229,7 +229,7 @@ function translateDrawing(g: Graph): void {
       // @see lib/common/postproc.c:map_edge ("lost %s %s edge")
       if (e.info.spl === undefined) {
         if (!(g.info.concentrate ?? false) && (e.info.edge_type ?? 0) !== IGNORED_EDGE) {
-          agerrLineOn('warn', `lost ${e.tail.name} ${e.head.name} edge`);
+          agerrorf(`lost ${e.tail.name} ${e.head.name} edge`);
         }
         continue;
       }

package/src/common/splines-clip.ts

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

package/src/common/splines-routespl.ts

@@ -15,7 +15,7 @@ import { shortestPath, routeSpline, makePolyline } from '../pathplan/index.js';
 import type { Poly } from '../pathplan/types.js';
 import { INIT_DELTA, LOOP_TRIES, ROUTESPL_FUDGE } from './splines-constants.js';
 import { fma } from './fma.js';
-import { agerrLineOn } from './agerr.js';
+import { agerrorf } from './agerr.js';
 
 // ---------------------------------------------------------------------------
 // Stage-dump hook (diagnosis only; null in production — same pattern as
@@ -451,7 +451,7 @@ function routeSplinesInternal(pp: Path, polyline: boolean): Point[] | null {
   if (pl === null) {
     // C: agerrorf("in routesplines, Pshortestpath failed") — the caller then
     // loses the edge. @see lib/common/routespl.c (Pshortestpath < 0 branch)
-    agerrLineOn('warn', 'in routesplines, Pshortestpath failed');
+    agerrorf('in routesplines, Pshortestpath failed');
     return null;
   }
   emitDump('S3_POLY', dumpNames, () => ({

package/src/common/textmeasure-lookup.ts

@@ -49,7 +49,7 @@ export function getFamilyMetrics(fontName: string): FontFamilyData {
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
     agwarningf(
-      `no hard-coded metrics for '${fontName}'.  ` +
+      `Warning: no hard-coded metrics for '${fontName}'.  ` +
         `Falling back to 'Times' metrics`,
     );
   }

package/src/gvc/context.ts

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

package/src/gvc/device-cluster.ts

@@ -6,13 +6,17 @@
 
 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 { gvrenderSetStyle, checkClusterStyleTokens } from './gvrender-set-style.js';
 import { resolveRenderColor, withColorScheme, reportColorNames } from '../render/color-resolve.js';
 import { parseSegs } from '../common/multicolor.js';
 
@@ -100,6 +104,9 @@ 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,
@@ -112,23 +119,71 @@ export function applyClusterObjState(sg: Graph, job: RenderJob): boolean {
 }
 
 /**
- * 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
+ * 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)
  */
-function stripedClusterColors(sg: Graph): string[] {
+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));
-  if (!flags.striped || flags.rounded) return [];
   const color = clusterAttr(sg, 'color') ?? '';
   let fill = clusterAttr(sg, 'fillcolor') || color;
   const bg = clusterAttr(sg, 'bgcolor') ?? '';
   if ((!flags.filled || fill === '') && bg !== '') fill = bg;
-  const { segs, error } = parseSegs(fill === '' ? 'lightgrey' : fill);
+  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; }

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,
@@ -47,8 +48,9 @@ import {
   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 { 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';
@@ -165,6 +167,9 @@ function setEdgePen(e: Edge, job: RenderJob): void {
   // 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 {
@@ -195,6 +200,10 @@ export function renderEdge(e: Edge, renderer: RendererPlugin, job: RenderJob): v
       // 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);
     });
@@ -230,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 });
@@ -280,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);
@@ -334,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);

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