@knowvah/dot-engine 2.3.1 → 2.4.0

package/src/parser/dot.pegjs

@@ -57,11 +57,22 @@ Stmt
 // grammar.y: attrtype : T_graph | T_node | T_edge
 // grammar.y: graphattrdefs : attrassignment  (bare key=value at graph level)
 AttrStmt
-  = t:AttrType _ attrs:AttrListReq
-    { return { type: "attr", target: t, attrs: attrs }; }
+  = t:AttrType _ m:OptMacroName attrs:AttrListReq
+    {
+      // 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");
+      return { type: "attr", target: t, attrs: attrs };
+    }
   / a:AttrAssignment
     { return { type: "assign", key: a.key, value: a.value }; }
 
+// grammar.y: optmacroname : atom '=' | /* empty */
+// @see grammar.y:nomacros -- agwarningf("attribute macros not implemented")
+OptMacroName
+  = Atom _ "=" _ { return true; }
+  / "" { return false; }
+
 // grammar.y: attrtype : T_graph | T_node | T_edge
 AttrType
   = GraphKw  { return "graph"; }
@@ -216,10 +227,13 @@ Name
   = first:[A-Za-z_\x80-￿] rest:[A-Za-z_0-9\x80-￿]*
     { return first + rest.join(""); }
 
-// scan.l: NUMBER = [-]?(({DIGIT}+(\.{DIGIT}*)?)|(\.{DIGIT}+))
-// Returned as string per spec requirement.
+// scan.l: NUMBER = [-]?(({DIGIT}+(\.{DIGIT}*)?)|(\.{DIGIT}+))(\.|{LETTER})?
+// There is no exponent: `1e5` lexes as NUMBER `1e`, which chkNum splits into
+// `1` and the NAME `e5`. The optional trailing '.'/LETTER is always split off
+// by chkNum (yyless), so it is never part of the atom; its warning is emitted
+// by number-scan.ts. Returned as string per spec requirement.
 NumericLiteral
-  = s:( "-"? ( [0-9]+ ( "." [0-9]* )? / "." [0-9]+ ) ( [eE] [+-]? [0-9]+ )? )
+  = s:( "-"? ( [0-9]+ ( "." [0-9]* )? / "." [0-9]+ ) )
     { return Array.isArray(s) ? s.flat(Infinity).filter(x => x !== null && x !== undefined).join("") : String(s); }
 
 // ── Case-insensitive keywords ─────────────────────────────────────────────────

package/src/parser/index.ts

@@ -13,6 +13,7 @@ import type { GraphKind } from '../model/graph.js';
 import type { Edge } from '../model/edge.js';
 import { isHtmlValue, htmlValueContent } from '../common/html-string.js';
 import { buildFromAst } from './builder.js';
+import { scanNumberAmbiguities, numberAmbiguityMessage } from './number-scan.js';
 import type { ParsedGraph } from './ast.js';
 import type { GvErrorCode, GvExpectation } from '../errors.js';
 import { DotEngineError, friendlyMessageFor, invalidArgType } from '../errors.js';
@@ -223,6 +224,18 @@ export function isPeggyError(err: unknown): err is {
  *   is too deep
  * @throws TypeError `ERR_INVALID_ARG_TYPE` if `src` is not a string
  */
+/**
+ * Emit scan.l's chkNum warnings for every badly delimited number the lexer
+ * reaches: all of them on success, those at or before a syntax error otherwise
+ * (C's lexer stops there). @see lib/cgraph/scan.l:chkNum
+ */
+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));
+  }
+}
+
 export function parse(src: string): Graph {
   if (typeof src !== 'string') {
     // Runtime guard for JS callers (the TS signature already forbids this):
@@ -235,6 +248,7 @@ export function parse(src: string): Graph {
   } catch (err: unknown) {
     if (isPeggyError(err)) {
       const start = err.location.start;
+      warnNumberAmbiguities(src, start.offset);
       const code: GvErrorCode =
         err.found === null ? 'SYNTAX_UNEXPECTED_EOF' : 'SYNTAX_ERROR';
       throw new ParseError(
@@ -256,6 +270,7 @@ export function parse(src: string): Graph {
     }
     throw err;
   }
+  warnNumberAmbiguities(src, src.length);
   validateEdgeOperators(src, ast.directed);
   return buildFromAst(ast);
 }

package/src/parser/number-scan.ts

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * scan.l's chkNum diagnostics. The NUMBER regexp allows one trailing '.' or
+ * LETTER so the lexer can catch a number run into a name (`00splines`) or a
+ * second dot (`1.2.3`); chkNum then warns and yyless() hands the last
+ * character back, splitting the text into two tokens. The PEG grammar already
+ * yields the split tokens; this pass reproduces the warnings, which a
+ * backtracking PEG action would emit unreliably (an alternative that fails
+ * after matching a number would re-run it).
+ *
+ * The walk runs over Stripper output (comments and string interiors blanked,
+ * same length, newlines kept), lexing the INITIAL-state tokens that can
+ * contain or abut a number: NAME, NUMBER, and the `--` / `->` edge operators.
+ *
+ * @see lib/cgraph/scan.l:106-110 (LETTER, DIGIT, NAME, NUMBER), :135, chkNum
+ */
+
+/** One chkNum warning: the matched NUMBER text and its line. */
+export interface NumberAmbiguity {
+  text: string;
+  line: number;
+  offset: number;
+}
+
+const ASCII_DEL = 0x7f;
+
+/** scan.l LETTER `[A-Za-z_\200-\377]`: any non-ASCII character counts. */
+function isLetter(c: string | undefined): boolean {
+  if (c === undefined) return false;
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_'
+    || c.charCodeAt(0) > ASCII_DEL;
+}
+
+function isDigit(c: string | undefined): boolean {
+  return c !== undefined && c >= '0' && c <= '9';
+}
+
+/** True when a NUMBER starts at i (sign, digits, or a dot before a digit). */
+function startsNumber(s: string, i: number): boolean {
+  const c = s[i];
+  if (isDigit(c)) return true;
+  if (c === '.') return isDigit(s[i + 1]);
+  if (c !== '-') return false;
+  return isDigit(s[i + 1]) || (s[i + 1] === '.' && isDigit(s[i + 2]));
+}
+
+/** End index of the longest NUMBER match starting at i (scan.l:109). */
+function matchNumber(s: string, i: number): number {
+  let j = s[i] === '-' ? i + 1 : i;
+  if (s[j] === '.') {
+    j++;
+    while (isDigit(s[j])) j++;
+  } else {
+    while (isDigit(s[j])) j++;
+    if (s[j] === '.') {
+      j++;
+      while (isDigit(s[j])) j++;
+    }
+  }
+  if (s[j] === '.' || isLetter(s[j])) j++;
+  return j;
+}
+
+/** scan.l twoDots: the first '.' is not the last character. */
+function twoDots(text: string): boolean {
+  const dot = text.indexOf('.');
+  return dot !== -1 && dot !== text.length - 1;
+}
+
+/** scan.l chkNum: the last character is a letter, or a second '.'. */
+function chkNum(text: string): boolean {
+  const c = text[text.length - 1]!;
+  return (!isDigit(c) && c !== '.') || (c === '.' && twoDots(text));
+}
+
+/**
+ * Lex one INITIAL token at i; returns the next index and, for a badly
+ * delimited NUMBER, its text (the next index is then yyless'd back by one).
+ */
+function lexToken(s: string, i: number): { next: number; bad: string | null } {
+  if (isLetter(s[i])) {
+    let j = i + 1;
+    while (isLetter(s[j]) || isDigit(s[j])) j++;
+    return { next: j, bad: null };
+  }
+  if (s[i] === '-' && (s[i + 1] === '-' || s[i + 1] === '>')) return { next: i + 2, bad: null };
+  if (!startsNumber(s, i)) return { next: i + 1, bad: null };
+  const j = matchNumber(s, i);
+  const text = s.slice(i, j);
+  return chkNum(text) ? { next: j - 1, bad: text } : { next: j, bad: null };
+}
+
+/**
+ * Every badly delimited NUMBER in `src`, in lexing order. `stripped` is
+ * Stripper.strip(src) (same length); tokens are lexed from it, lines are
+ * counted in `src` (the stripper blanks newlines inside comments and strings,
+ * which scan.l still counts). @see lib/cgraph/scan.l:chkNum
+ */
+export function scanNumberAmbiguities(src: string, stripped: string): NumberAmbiguity[] {
+  const out: NumberAmbiguity[] = [];
+  let line = 1;
+  let lineAt = 0;
+  for (let i = 0; i < stripped.length;) {
+    const { next, bad } = lexToken(stripped, i);
+    if (bad !== null) {
+      for (; lineAt < i; lineAt++) if (src[lineAt] === '\n') line++;
+      out.push({ text: bad, line, offset: i });
+    }
+    i = next;
+  }
+  return out;
+}
+
+/** agwarningf text for one chkNum ambiguity; a parsed string is "input". */
+export function numberAmbiguityMessage(a: NumberAmbiguity): string {
+  return `Warning: syntax ambiguity - badly delimited number '${a.text}' in line ${a.line} of input splits into two tokens`;
+}

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

@@ -18,6 +18,7 @@ import type { ArrowDrawOp } from '../../common/arrows-types.js';
 import type { GVColor } from '../../common/color.js';
 import type { RenderJob } from '../../gvc/job.js';
 import { EmitState } from '../../gvc/job.js';
+import { PenType } from '../../gvc/context.js';
 import { resolveRenderColor } from '../color-resolve.js';
 import { taper, taperfun } from '../../common/taper.js';
 import { orthoRoundedRadius } from '../svg-helpers.js';
@@ -31,6 +32,9 @@ import { DotWriterBase } from './agwrite.js';
 /** Pen colour when a colour-list entry is empty. @see lib/common/emit.c:2485 */
 const DEFAULT_COLOR = 'black';
 
+/** gvc->defaultlinestyle as style tokens. @see lib/common/emit.c:105 */
+const DEFAULT_LINE_STYLE: readonly string[] = ['solid', 'setlinewidth(1)'];
+
 /**
  * One arrow primitive as an xdot op. Lifted out of emitArrows' loop unchanged —
  * the four cases and their `filled` variants are exactly arrow_gen's.
@@ -64,6 +68,27 @@ export abstract class EdgeDrawBase extends DotWriterBase {
   protected penwidth: number[] = new Array(12).fill(1);
   protected abstract styleOp(job: RenderJob): string;
   protected abstract penOp(job: RenderJob): string;
+  abstract polyline(pts: Point[], job: RenderJob): void;
+
+  /**
+   * emit_attachment's draw calls (decorate=true): gvrender_set_style with the
+   * default line style sets the obj's rawstyle/pen/penwidth (setlinewidth 1),
+   * gvrender_set_pencolor sets the pen to the label fontcolor (first entry of
+   * a color list), then gvrender_polyline → xdot_polyline emits the style ops
+   * (`S 5 -solid`; setlinewidth is filtered), the pen color and `L 3`.
+   * @see lib/common/emit.c:emit_attachment (1886-1893)
+   * @see lib/gvc/gvrender.c:gvrender_set_style / gvrender_set_pencolor
+   */
+  attachmentPolyline(pts: Point[], pencolor: string, job: RenderJob): void {
+    const obj = job.obj;
+    if (obj !== null) {
+      obj.rawStyle = [...DEFAULT_LINE_STYLE];
+      obj.pen = PenType.Solid;
+      obj.penWidth = 1;
+      obj.penColor = resolveRenderColor(pencolor.split(':')[0]!);
+    }
+    this.polyline(pts, job);
+  }
 
   /**
    * The plain single-colour spline branch of beginEdge — lifted verbatim so the

package/src/render/svg-graph.ts

@@ -16,12 +16,12 @@ import type { Box, Point } from '../model/geom.js';
 import type { RenderJob } from '../gvc/job.js';
 import { createObjState, ObjType } from '../gvc/job.js';
 import { FillType } from '../gvc/context.js';
-import { escapeXml, escapeXmlTitle } from './svg-helpers.js';
+import { escapeXml, escapeXmlTitle, svgComment } from './svg-helpers.js';
 import { resolveRenderColor, colorPaint } from './color-resolve.js';
 import { svgGraphId, svgGraphClass } from './svg-id.js';
 import { parseGradientSpec } from '../common/htmltable-emit-fill.js';
 import { findStopColor, parseStyleFlags } from '../common/style-resolve.js';
-import { cround } from '../common/arith.js';
+import { croundNarrow32 } from '../common/arith.js';
 import { FontnameKind } from '../model/layoutParams.js';
 import {
   emitLinearGradient,
@@ -66,7 +66,7 @@ function formatG(n: number): string {
  * (svgBeginPage). ViewBox starts at (round(margin.x), round(margin.y)) --
  * (0,0) only in the common no-margin case.
  */
-export function emitSvgTag(job: RenderJob): void {
+export function emitSvgTag(job: RenderJob, svgid: string | undefined = ''): void {
   const bb = job.bb;
   // Size-fitted, UNROUNDED page-oriented view extent (init_job_pagination's
   // local `imageSize`/`pageSize`, emit.c:1198-1246): sz = bb extent plus pad,
@@ -87,8 +87,11 @@ export function emitSvgTag(job: RenderJob): void {
   const pageX = rotated ? viewY : viewX;
   const pageY = rotated ? viewX : viewY;
   // job->width/job->height (emit.c:1249-1250, dpi=72 so *dpi/72 is a no-op).
-  const w = cround(pageX + 2 * job.margin.x);
-  const h = cround(pageY + 2 * job.margin.y);
+  // The native build vectorises these ROUNDs (fcvtzs.2d + xtn: low 32 bits of
+  // an int64), so an out-of-range page size wraps exactly as native prints it
+  // (2784: 2.16e18 -> 1255669760). @see croundNarrow32
+  const w = croundNarrow32(pageX + 2 * job.margin.x);
+  const h = croundNarrow32(pageY + 2 * job.margin.y);
   job.write('<svg width="' + String(w) + 'pt" height="' + String(h) + 'pt"\n');
   // job->pageBoundingBox (canvasBox.LL = margin+centering, canvasBox.UR = LL +
   // imageSize, then ROUND -- emit.c:1282-1293). C's rotation-branch double
@@ -96,14 +99,20 @@ export function emitSvgTag(job: RenderJob): void {
   // swap-back, emit.c:1275-1298) cancels for LL (always plain margin) but NOT
   // for UR, which ends up paired with the page-oriented (rotation-swapped)
   // view extent -- i.e. the same `pageX`/`pageY` used for width/height above.
-  const vbLLx = cround(job.margin.x);
-  const vbLLy = cround(job.margin.y);
-  const vbURx = cround(job.margin.x + pageX);
-  const vbURy = cround(job.margin.y + pageY);
+  const vbLLx = croundNarrow32(job.margin.x);
+  const vbLLy = croundNarrow32(job.margin.y);
+  const vbURx = croundNarrow32(job.margin.x + pageX);
+  const vbURy = croundNarrow32(job.margin.y + pageY);
   job.write('     viewBox="' + String(vbLLx) + '.00 ' + String(vbLLy) + '.00 ' +
     String(vbURx) + '.00 ' + String(vbURy) + '.00"\n');
   job.write('     xmlns="http://www.w3.org/2000/svg"');
-  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink">\n');
+  job.write(' xmlns:xlink="http://www.w3.org/1999/xlink"');
+  // graphviz 16.1: `svgid` graph attribute -> id on the root <svg> (gvputs_xml).
+  // @see plugin/core/gvrender_core_svg.c:svg_begin_graph
+  if (svgid !== undefined && svgid.length > 0) {
+    job.write(' id="' + escapeXmlTitle(svgid) + '"');
+  }
+  job.write('>\n');
 }
 
 /**
@@ -175,22 +184,23 @@ export function resolveGraphBgcolor(bgcolorAttr: string | undefined): string {
 }
 
 /**
- * Emit background polygon covering the full padded content area.
+ * Emit background polygon covering the page clip box (C gvrender_box over
+ * job->clip — bb ± pad as setup_page evaluates it, see setupPageClip).
  *
  * Omits the polygon entirely when resolvedColor is the transparent sentinel.
  * Coordinates are in the group's local frame (y-flipped via devscale.y=-1):
- *   x: [bb.ll.x - PAD, bb.ur.x + PAD]
- *   y (flipped): [-(bb.ur.y + PAD), -(bb.ll.y - PAD)]
+ *   x: [clip.ll.x, clip.ur.x]
+ *   y (flipped): [-clip.ur.y, -clip.ll.y]
  *
  * @see plugin/core/gvrender_core_svg.c:svg_begin_page
  * @see lib/common/emit.c:emit_background:1476
  */
-export function emitGraphBackground(bb: Box, resolvedColor: string, job: RenderJob): void {
+export function emitGraphBackground(clip: Box, resolvedColor: string, job: RenderJob): void {
   if (resolvedColor === BGCOLOR_TRANSPARENT) return;
-  const left   = bb.ll.x - job.pad.x;
-  const right  = bb.ur.x + job.pad.x;
-  const top    = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+  const left   = clip.ll.x;
+  const right  = clip.ur.x;
+  const top    = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners: [number, number][] = [
     [left, bottom], [left, top], [right, top], [right, bottom], [left, bottom],
   ];
@@ -209,11 +219,11 @@ export function emitGraphBackground(bb: Box, resolvedColor: string, job: RenderJ
  * Passed to getGradientPoints inside emitLinearGradient.
  * @see lib/common/emit.c:emit_background:1517 (gvrender_box with clip)
  */
-function bgGradientPts(bb: Box, pad: Point): Point[] {
-  const left   = bb.ll.x - pad.x;
-  const right  = bb.ur.x + pad.x;
-  const bottom = bb.ll.y - pad.y;
-  const top    = bb.ur.y + pad.y;
+function bgGradientPts(clip: Box): Point[] {
+  const left   = clip.ll.x;
+  const right  = clip.ur.x;
+  const bottom = clip.ll.y;
+  const top    = clip.ur.y;
   return [
     { x: left,  y: bottom },
     { x: left,  y: top    },
@@ -227,11 +237,11 @@ function bgGradientPts(bb: Box, pad: Point): Point[] {
  * Coords identical to emitGraphBackground; only fill changes.
  * @see plugin/core/gvrender_core_svg.c:svg_polygon:686
  */
-function writeGradientPolygon(bb: Box, id: string, job: RenderJob): void {
-  const left   = bb.ll.x - job.pad.x;
-  const right  = bb.ur.x + job.pad.x;
-  const top    = -(bb.ur.y + job.pad.y);
-  const bottom = -(bb.ll.y - job.pad.y);
+function writeGradientPolygon(clip: Box, id: string, job: RenderJob): void {
+  const left   = clip.ll.x;
+  const right  = clip.ur.x;
+  const top    = -clip.ur.y;
+  const bottom = -clip.ll.y;
   const corners: [number, number][] = [
     [left, bottom], [left, top], [right, top], [right, bottom], [left, bottom],
   ];
@@ -256,7 +266,7 @@ function writeGradientPolygon(bb: Box, id: string, job: RenderJob): void {
  * @see plugin/core/gvrender_core_svg.c:svg_gradstyle:572
  * @see plugin/core/gvrender_core_svg.c:svg_rgradstyle:608
  */
-function emitGradientBackground(bb: Box, spec: BgGradientSpec, job: RenderJob): void {
+function emitGradientBackground(clip: Box, spec: BgGradientSpec, job: RenderJob): void {
   const obj = createObjState(ObjType.RootGraph);
   obj.id = 'graph0';
   obj.fillColor = resolveRenderColor(spec.fillColor);
@@ -271,10 +281,10 @@ function emitGradientBackground(bb: Box, spec: BgGradientSpec, job: RenderJob):
     emitRadialGradient(job, gid);
   } else {
     gid = gradientId('graph0', 'l', job.linearGradId++);
-    emitLinearGradient(job, bgGradientPts(bb, job.pad), gid);
+    emitLinearGradient(job, bgGradientPts(clip), gid);
   }
   job.popObj();
-  writeGradientPolygon(bb, gid, job);
+  writeGradientPolygon(clip, gid, job);
 }
 
 /**
@@ -296,17 +306,17 @@ function resolveBgGradientSpec(g: Graph, bgcolorAttr: string): BgGradientSpec |
  * Separated to keep svgBeginGraph under the 30-line body limit.
  * @see lib/common/emit.c:emit_background:1476
  */
-function emitBgcolorBackground(g: Graph, bb: Box, bgcolorAttr: string | undefined, job: RenderJob): void {
+function emitBgcolorBackground(g: Graph, clip: Box, bgcolorAttr: string | undefined, job: RenderJob): void {
   if (!bgcolorAttr || bgcolorAttr.length === 0 || bgcolorAttr === 'transparent') {
-    emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+    emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
     return;
   }
   const spec = resolveBgGradientSpec(g, bgcolorAttr);
   if (spec !== null) {
-    emitGradientBackground(bb, spec, job);
+    emitGradientBackground(clip, spec, job);
     return;
   }
-  emitGraphBackground(bb, resolveGraphBgcolor(bgcolorAttr), job);
+  emitGraphBackground(clip, resolveGraphBgcolor(bgcolorAttr), job);
 }
 
 /**
@@ -344,7 +354,25 @@ export function svgBeginGraph(g: Graph, job: RenderJob): void {
   }
   job.write(SVG_DOCTYPE);
   job.write(SVG_GENERATOR_COMMENT);
-  emitSvgTag(job);
+  // emit_graph: the root `comment` attribute, between svg_begin_job and
+  // emit_begin_graph. @see lib/common/emit.c:emit_graph
+  const comment = g.attrs.get('comment');
+  if (comment !== undefined && comment.length > 0) svgComment(comment, job);
+  emitTitlePagesComment(g, job);
+  emitSvgTag(job, g.attrs.get('svgid'));
+}
+
+/**
+ * svg_begin_graph's header comment: ` Title: <name>` for a user-named graph,
+ * then the page count (always 1 — the port emits a single page).
+ * @see plugin/core/gvrender_core_svg.c:svg_begin_graph
+ */
+function emitTitlePagesComment(g: Graph, job: RenderJob): void {
+  job.write('<!--');
+  if (g.name.length > 0 && g.name[0] !== '%') {
+    job.write(' Title: ' + escapeXmlTitle(g.name));
+  }
+  job.write(' Pages: 1 -->\n');
 }
 
 /**
@@ -353,14 +381,16 @@ export function svgBeginGraph(g: Graph, job: RenderJob): void {
  * @see plugin/core/gvrender_core_svg.c:svg_begin_page
  */
 export function svgBeginPage(g: Graph, job: RenderJob): void {
-  const bb = job.bb;
-  // gvPostprocess zeroes bb.ll before render; tx is simply the padding.
+  const clip = job.clip;
+  // Portrait: translation.x = -clip.LL.x, with job->clip as setup_page builds
+  // it (setupPageClip: focus ∓ pageSize/2, i.e. bb ± pad up to rounding).
+  // gvPostprocess normally zeroes bb.ll, but a dot layout failure skips it
+  // (graphviz 16.1, corpus 2784: translate(31 ...)).
   // Landscape (ADR-3): setup_page's rotation branch (SVG = GVRENDER_Y_GOES_DOWN)
-  // gives translation.x = -(focus.x + pageSize.x/2) = -(bb.ur.x + PAD) in the
-  // zeroed-bb frame; translation.y is unchanged (focus.y + pageSize.y/2 =
-  // bb.ur.y + PAD). pageSize = imageSize/zoom is Z-independent (outer scale
-  // carries Z), so the formula holds for any size= fit. Pinned to b68 native
-  // translate(-634 208.5). @see emit.c:setup_page; gvrender_core_svg.c:svg_begin_page
+  // gives translation.x = -clip.UR.x; translation.y = -clip.UR.y in both
+  // branches (printed negated). pageSize = imageSize/zoom is Z-independent
+  // (outer scale carries Z). Pinned to b68 native translate(-634 208.5).
+  // @see emit.c:setup_page; gvrender_core_svg.c:svg_begin_page
   //
   // margin (F6): setup_page adds `canvasBox.LL / job->zoom` on top of the
   // pad-only formula above -- canvasBox.LL is the FINAL (post swap-cancel)
@@ -374,9 +404,9 @@ export function svgBeginPage(g: Graph, job: RenderJob): void {
   // @see lib/common/emit.c:1566-1582 setup_page (CAUTION comment there)
   const z = job.scale.x;
   const tx = job.rotation !== 0
-    ? -(bb.ur.x + job.pad.x) - job.margin.x / z
-    : job.pad.x + job.margin.x / z;
-  const ty = bb.ur.y + job.pad.y + job.margin.y / z;
+    ? -clip.ur.x - job.margin.x / z
+    : -clip.ll.x + job.margin.x / z;
+  const ty = clip.ur.y + job.margin.y / z;
   emitGraphGroupOpen(
     job.idLayerPrefix() + svgGraphId(g, job),
     svgGraphClass(g),
@@ -393,7 +423,7 @@ export function svgBeginPage(g: Graph, job: RenderJob): void {
  * @see lib/common/emit.c:emit_page (emit_background after begin_page)
  */
 export function svgPageBackground(g: Graph, job: RenderJob): void {
-  emitBgcolorBackground(g, job.bb, g.attrs.get('bgcolor'), job);
+  emitBgcolorBackground(g, job.clip, g.attrs.get('bgcolor'), job);
 }
 
 /** Close the graph `<g>` group. @see svg_end_page */

package/src/render/svg-helpers.ts

@@ -421,8 +421,8 @@ export function svgPolyline(pts: Point[], job: RenderJob): void {
   job.write('"/>\n');
 }
 
-export function svgComment(text: string, job: RenderJob): void {
-  job.write('<!-- ' + escapeXml(text) + ' -->\n');
+export function svgComment(text: string, job: RenderJob): void { // svg_comment: gvputs_xml
+  job.write('<!-- ' + escapeXmlTitle(text) + ' -->\n');
 }
 
 // ---------------------------------------------------------------------------

package/src/render/svg.ts

@@ -20,13 +20,12 @@ import type { Graph } from '../model/graph.js';
 import type { Node } from '../model/node.js';
 import type { Edge } from '../model/edge.js';
 import type { Point, Box } from '../model/geom.js';
-import { boxOverlap } from '../model/geom.js';
-import type { TextlabelT } from '../common/types.js';
 import type { TextSpan } from '../common/emit-types.js';
 import type { RendererPlugin, LabelType } from '../gvc/context.js';
 import type { RenderJob } from '../gvc/job.js';
 import { renderEdgeLabels } from '../gvc/edge-labels.js';
 import { beginAnchorIf } from '../gvc/anchor.js';
+import { edgeHasDrawableContent } from '../common/edge-in-box.js';
 import {
   svgBeginGraph,
   svgEndGraph,
@@ -86,45 +85,9 @@ function emitMulticolorArrows(e: Edge, job: RenderJob, headColor: string, tailCo
 // @see plugin/core/gvrender_core_svg.c:svg_engine
 // ---------------------------------------------------------------------------
 
-/** overlap_label: does the label's box (pos ± dimen/2) overlap clip box b?
- * @see lib/common/utils.c:overlap_label */
-function overlapLabel(lp: TextlabelT, b: Box): boolean {
-  const sx = lp.dimen.x / 2;
-  const sy = lp.dimen.y / 2;
-  const bb: Box = {
-    ll: { x: lp.pos.x - sx, y: lp.pos.y - sy },
-    ur: { x: lp.pos.x + sx, y: lp.pos.y + sy },
-  };
-  return boxOverlap(b, bb);
-}
-
-/**
- * Faithful-to-outcome `edge_in_box`: true when the edge has something to draw.
- * C's gvrender defers the `<g>` until a draw op, so an edge whose content falls
- * entirely outside the clip emits no group (emit.c:edge_in_box tests each piece
- * vs job->clip via boxf_overlap/overlap_label).
- *
- * The only piece that can legitimately fall OUTSIDE the clip on this corpus is a
- * degenerate labeled-flat label: it is spline-less, so map_edge leaves it at its
- * internal (un-normalized) x-frame position while the clip is the final frame.
- * The `overlapLabel` test on the main label reproduces C's draw-iff-overlap for
- * exactly that case — on-canvas (2368) → drawn; off-canvas (2368_1, negative
- * un-normalized x) → suppressed. A present spline always lies within the clip
- * (GD_bb contains it), and head/tail/xlabels are positioned at on-canvas
- * endpoints, so those keep their existing unconditional triggers — adding an
- * overlap test there only risks suppressing legitimately-drawn content (it
- * regressed neato/circo edges whose spl.bb is computed differently). The `set`
- * guard on the main label is kept: the port retains an unplaced (`pos=0,0`,
- * `set=false`) label on merged back-edges where C has none.
- * @see lib/common/emit.c:edge_in_box, lib/common/utils.c:overlap_label
- */
-export function edgeHasDrawableContent(e: Edge, clip: Box): boolean {
-  const i = e.info;
-  return i.spl !== undefined
-    || (i.label !== undefined && i.label.set && overlapLabel(i.label, clip))
-    || i.xlabel !== undefined
-    || i.head_label !== undefined || i.tail_label !== undefined;
-}
+// edge_in_box gate lives in common/edge-in-box.ts (shared with the device walk);
+// re-exported for existing import sites.
+export { edgeHasDrawableContent };
 
 export class SvgRenderer implements RendererPlugin {
   readonly type = 'svg';

package/src/xdot/parse.ts

@@ -13,6 +13,9 @@ import type {
 } from "./types.js";
 import { XDOT_PARSE_ERROR } from "./types.js";
 
+/** ULONG_MAX on an LP64 target: strtoul saturation value. */
+const ULONG_MAX = 0xffff_ffff_ffff_ffffn;
+
 type PR<T> = { val: T; pos: number } | null;
 type OpResult = { op: XdotOp; pos: number } | "error";
 type OpMaybeResult = OpResult | null;
@@ -63,12 +66,23 @@ class XdotParser {
     return { val: parseInt(s.slice(start, i), 10), pos: i };
   }
 
+  /**
+   * strtoul(s, &endp, 10) cast to unsigned int: optional sign, a leading "-"
+   * negates modulo 2^64, magnitude overflow saturates to ULONG_MAX, and the
+   * result keeps the low 32 bits.
+   * @see lib/xdot/xdot.c:parseUInt
+   */
   static parseUInt_(s: string, pos: number): PR<number> {
     const i = XdotParser.skipWs(s, pos);
-    const start = i;
-    const end = XdotParser.consumeDigits(s, i);
+    let start = i;
+    const negative = i < s.length && s[i] === "-";
+    if (i < s.length && (s[i] === "-" || s[i] === "+")) start++;
+    const end = XdotParser.consumeDigits(s, start);
     if (end === start) return null;
-    return { val: parseInt(s.slice(start, end), 10), pos: end };
+    const mag = BigInt(s.slice(start, end));
+    const clamped = mag > ULONG_MAX ? ULONG_MAX : mag;
+    const wrapped = negative && mag <= ULONG_MAX ? BigInt.asUintN(64, -clamped) : clamped;
+    return { val: Number(BigInt.asUintN(32, wrapped)), pos: end };
   }
 
   static parseRect(s: string, pos: number): PR<XdotRect> {
@@ -163,7 +177,7 @@ class XdotParser {
     const ry0 = XdotParser.parseReal(s, rx0.pos); if (!ry0) return null;
     const rx1 = XdotParser.parseReal(s, ry0.pos); if (!rx1) return null;
     const ry1 = XdotParser.parseReal(s, rx1.pos); if (!ry1) return null;
-    const rn = XdotParser.parseInt_(s, ry1.pos); if (!rn) return null;
+    const rn = XdotParser.parseUInt_(s, ry1.pos); if (!rn) return null;
     const rs = XdotParser.parseStops(s, rn.pos, rn.val); if (!rs) return null;
     return { x0: rx0.val, y0: ry0.val, x1: rx1.val, y1: ry1.val, stops: rs.stops };
   }
@@ -175,7 +189,7 @@ class XdotParser {
     const rx1 = XdotParser.parseReal(s, rr0.pos); if (!rx1) return null;
     const ry1 = XdotParser.parseReal(s, rx1.pos); if (!ry1) return null;
     const rr1 = XdotParser.parseReal(s, ry1.pos); if (!rr1) return null;
-    const rn = XdotParser.parseInt_(s, rr1.pos); if (!rn) return null;
+    const rn = XdotParser.parseUInt_(s, rr1.pos); if (!rn) return null;
     const rs = XdotParser.parseStops(s, rn.pos, rn.val); if (!rs) return null;
     return { x0: rx0.val, y0: ry0.val, r0: rr0.val, x1: rx1.val, y1: ry1.val, r1: rr1.val, stops: rs.stops };
   }