@knowvah/dot-engine 1.1.1 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "Faithful TypeScript port of Graphviz (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork) — no C: no native binary, no WASM. Oracle-verified against the C implementation, runs in the browser.",
   "keywords": [
     "graphviz",

package/src/common/arrows.ts

@@ -14,7 +14,7 @@ import {
   ARR_MOD_OPEN, ARR_MOD_INV, ARR_MOD_LEFT, ARR_MOD_RIGHT,
   ARR_TYPE_NORM, ARR_TYPE_CROW, ARR_TYPE_TEE, ARR_TYPE_BOX,
   ARR_TYPE_DIAMOND, ARR_TYPE_DOT, ARR_TYPE_CURVE, ARR_TYPE_GAP,
-  ARR_TYPE_MASK, ARR_LENFACT_BY_TYPE,
+  ARR_TYPE_MASK, ARR_LENFACT_BY_TYPE, NUMB_OF_ARROW_HEADS,
 } from './arrows-constants.js';
 
 // ---------------------------------------------------------------------------
@@ -125,13 +125,26 @@ const parseOne = (s: string): { comp: ArrowComponent; rest: string } | null => {
 export function parseArrow(str: string): ArrowComponent[] {
   const result: ArrowComponent[] = [];
   let s = str;
-  while (s.length > 0) {
+  // C warns and returns on an unparseable fragment, leaving *flag as whatever
+  // was accumulated; only a name that fails on the FIRST fragment yields the
+  // "no arrow spec at all" case the caller's `normal` default covers.
+  let parsedAny = false;
+  // C's loop counter `i` advances only when a component is STORED, so a gap
+  // dropped by the rules below does not consume one of the four slots.
+  while (s.length > 0 && result.length < NUMB_OF_ARROW_HEADS) {
     const m = parseOne(s);
     if (!m) break;
-    result.push(m.comp);
+    parsedAny = true;
     s = m.rest;
+    const isGap = m.comp.name === 'none';
+    // A GAP in the LAST slot is dropped — `arrowhead="teeteeteenone"` draws
+    // three arrows, not three plus a trailing spacer.
+    if (isGap && result.length === NUMB_OF_ARROW_HEADS - 1) continue;
+    // A GAP that is the entire spec is dropped (`arrowhead=none` → no arrow).
+    if (isGap && result.length === 0 && s.length === 0) continue;
+    result.push(m.comp);
   }
-  if (result.length === 0) result.push({ name: 'normal', open: false, left: false, right: false });
+  if (!parsedAny) result.push({ name: 'normal', open: false, left: false, right: false });
   return result;
 }
 

package/src/common/edge-label-init.ts

@@ -145,8 +145,15 @@ function applyLabel(e: Edge, g: Graph, fi: FontInfo, measurer: TextMeasurer): vo
   e.info.label = makeAnyLabel(content, isHtml, fi, measurer, e);
   g.root.info.has_labels |= EDGE_LABEL;
   // ED_label_ontop: mapbool(late_string(e, E_label_float, "false"))
-  // @see lib/common/utils.c:522
-  e.info.label_ontop = mapbool(e.attrs.get('label_float')) ? 1 : 0;
+  //
+  // The user-facing attribute is `labelfloat`, with no underscore — that is the
+  // name E_label_float is BOUND from (input.c:770). `label_float` (underscore)
+  // appears only at dotsplines.c:738, where it is rebound against the internal
+  // aux graph. Reading the underscored name here honoured an attribute C
+  // ignores and ignored the one it honours; no corpus graph declares either, so
+  // no parity track could see it (test/corpus/attr-frequency.ts).
+  // @see lib/common/utils.c:522 · lib/common/input.c:770
+  e.info.label_ontop = mapbool(e.attrs.get('labelfloat')) ? 1 : 0;
 }
 
 // ---------------------------------------------------------------------------

package/src/common/htmltable-emit.ts

@@ -258,6 +258,23 @@ export function emitHtmlImg(
  *
  * @see lib/common/htmltable.c:emit_html_cell
  */
+/**
+ * True when an HTML element's STYLE declares it invisible.
+ *
+ * HTML STYLE is lexed by its OWN parser, not the node/edge one: tokens are
+ * split on space or comma, compared case-insensitively, and BOTH "INVIS" and
+ * "INVISIBLE" set the flag. (The node/edge parser splits on comma only and
+ * matches exact-case, so it cannot be reused here.)
+ * @see lib/common/htmllex.c:168 (DELIM " ,", strview_case_str_eq)
+ */
+function htmlStyleInvisible(style: string | undefined): boolean {
+  if (style === undefined) return false;
+  return style.split(/[ ,]+/).some((tok) => {
+    const t = tok.toUpperCase();
+    return t === 'INVIS' || t === 'INVISIBLE';
+  });
+}
+
 export function emitHtmlCell(
   cell: PlacedCell,
   pos: Point,
@@ -268,6 +285,12 @@ export function emitHtmlCell(
     { href: cell.href, title: cell.title, target: cell.target, id: cell.id },
     absBox(cell.box, pos), renderer, job,
   );
+  // An invisible cell emits no fill, no border and no content — only the
+  // anchor, which C opens before the gate. @see htmltable.c:emit_html_cell:643
+  if (htmlStyleInvisible(cell.style)) {
+    if (inAnchor) endHtmlAnchor(renderer, job);
+    return;
+  }
   emitCellDecoration(cell, pos, renderer, job);
   if (cell.nested !== undefined) {
     // C: emit_html_cell recurses emit_html_tbl for an HTML_TBL child.
@@ -329,14 +352,19 @@ export function emitHtmlLabel(
   // @see lib/common/htmltable.c:emit_html_tbl (537, 583-588)
   const clustersLast = (job.flags & EMIT_CLUSTERS_LAST) !== 0;
   const inAnchor = clustersLast ? false : initHtmlAnchor(anchorData, tblBox, renderer, job);
-  if (placed.bgcolor !== undefined) {
-    emitBgFill({ bgcolor: placed.bgcolor, box: placed.box, pos, border: placed.border,
-      renderer, job, gradientangle: placed.gradientangle, style: placed.style });
-  }
-  for (const cell of placed.cells) emitHtmlCell(cell, pos, renderer, job);
-  emitTableRules(placed, pos, renderer, job);
-  if (placed.border > 0) {
-    emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
+  // An invisible TABLE suppresses its fill, ALL its cells, and its rules and
+  // border — the whole block C guards at emit_html_tbl:542.
+  const tblInvisible = htmlStyleInvisible(placed.style);
+  if (!tblInvisible) {
+    if (placed.bgcolor !== undefined) {
+      emitBgFill({ bgcolor: placed.bgcolor, box: placed.box, pos, border: placed.border,
+        renderer, job, gradientangle: placed.gradientangle, style: placed.style });
+    }
+    for (const cell of placed.cells) emitHtmlCell(cell, pos, renderer, job);
+    emitTableRules(placed, pos, renderer, job);
+    if (placed.border > 0) {
+      emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
+    }
   }
   if (inAnchor) endHtmlAnchor(renderer, job);
   if (clustersLast && initHtmlAnchor(anchorData, tblBox, renderer, job)) {

package/src/common/poly-gencode.ts

@@ -33,7 +33,7 @@ import {
   styleTokens,
 } from './style-resolve.js';
 import { stripedBox, wedgedEllipse } from '../render/svg-multicolor.js';
-import { resolveRenderColor, withColorScheme } from '../render/color-resolve.js';
+import { resolveRenderColor } from '../render/color-resolve.js';
 import { svgNodeId } from '../render/svg-id.js';
 import { drawRoundCorners, mcircleHack, underlineDraw } from './poly-shapes.js';
 
@@ -349,13 +349,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');
-  // C wraps each node's color block with setColorScheme so a `colorscheme`
-  // attr applies to bare scheme indices. @see lib/common/emit.c:1781/1789
-  return withColorScheme(nodeAttr(n, n.root, 'colorscheme'), () => {
-    const filled = applyFillState(obj, n, job);
-    applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, 'penwidth'));
-    return filled;
-  });
+  // 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
+  // codefns, so they already run inside that window. @see gvc/device.ts
+  const filled = applyFillState(obj, n, job);
+  applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, 'penwidth'));
+  return filled;
 }
 
 /**

package/src/common/ps-fontalias.ts

@@ -15,66 +15,77 @@
 // "Times New Roman" on _WIN32. The oracle and goldens are non-Windows, so the
 // non-Windows family strings are used here.
 
+import { FontnameKind } from '../model/layoutParams.js';
+
 /**
- * One PostScript-font alias entry (the fields the SVG renderer uses in the
- * default NATIVEFONTS mode). `xfig_code` and the SVGFONTS-only svg_font_weight/
- * svg_font_style fields are intentionally omitted — unused for SVG output.
+ * One PostScript-font alias entry. `xfig_code` is omitted (xfig output is a
+ * non-goal); every other field is carried, because the `fontnames` graph
+ * attribute selects WHICH of them the SVG emitter uses.
  * @see lib/common/textspan.h _PostscriptAlias
  */
 export interface PostscriptAlias {
+  /** The PostScript name itself — the family under PSFONTS. */
+  name: string;
   family: string;
   weight: string | null;
   stretch: string | null;
   style: string | null;
   svgFontFamily: string;
+  svgFontWeight: string | null;
+  svgFontStyle: string | null;
 }
 
 // Rows ported verbatim from ps_font_equiv.h (macros resolved, non-Windows):
-// [name, family, weight, stretch, style, svgFontFamily].
+// [name, family, weight, stretch, style, svgFontFamily, svgFontWeight,
+//  svgFontStyle].
 const ALIAS_ROWS: readonly (readonly [
   string, string, string | null, string | null, string | null, string,
+  string | null, string | null,
 ])[] = [
-  ['AvantGarde-Book', 'URW Gothic L', 'book', null, null, 'sans-Serif'],
-  ['AvantGarde-BookOblique', 'URW Gothic L', 'book', null, 'oblique', 'sans-Serif'],
-  ['AvantGarde-Demi', 'URW Gothic L', 'demi', null, null, 'sans-Serif'],
-  ['AvantGarde-DemiOblique', 'URW Gothic L', 'demi', null, 'oblique', 'sans-Serif'],
-  ['Bookman-Demi', 'URW Bookman L', 'demi', null, null, 'serif'],
-  ['Bookman-DemiItalic', 'URW Bookman L', 'demi', null, 'italic', 'serif'],
-  ['Bookman-Light', 'URW Bookman L', 'light', null, null, 'serif'],
-  ['Bookman-LightItalic', 'URW Bookman L', 'light', null, 'italic', 'serif'],
-  ['Courier', 'Courier', null, null, null, 'monospace'],
-  ['Courier-Bold', 'Courier', 'bold', null, null, 'monospace'],
-  ['Courier-BoldOblique', 'Courier', 'bold', null, 'oblique', 'monospace'],
-  ['Courier-Oblique', 'Courier', null, null, 'oblique', 'monospace'],
-  ['Helvetica', 'Helvetica', null, null, null, 'sans-Serif'],
-  ['Helvetica-Bold', 'Helvetica', 'bold', null, null, 'sans-Serif'],
-  ['Helvetica-BoldOblique', 'Helvetica', 'bold', null, 'oblique', 'sans-Serif'],
-  ['Helvetica-Narrow', 'Helvetica', null, 'condensed', null, 'sans-Serif'],
-  ['Helvetica-Narrow-Bold', 'Helvetica', 'bold', 'condensed', null, 'sans-Serif'],
-  ['Helvetica-Narrow-BoldOblique', 'Helvetica', 'bold', 'condensed', 'oblique', 'sans-Serif'],
-  ['Helvetica-Narrow-Oblique', 'Helvetica', null, 'condensed', 'oblique', 'sans-Serif'],
-  ['Helvetica-Oblique', 'Helvetica', null, null, 'oblique', 'sans-Serif'],
-  ['NewCenturySchlbk-Bold', 'Century Schoolbook L', 'bold', null, null, 'serif'],
-  ['NewCenturySchlbk-BoldItalic', 'Century Schoolbook L', 'bold', null, 'italic', 'serif'],
-  ['NewCenturySchlbk-Italic', 'Century Schoolbook L', null, null, 'italic', 'serif'],
-  ['NewCenturySchlbk-Roman', 'Century Schoolbook L', 'roman', null, null, 'serif'],
-  ['Palatino-Bold', 'Palatino Linotype', 'bold', null, null, 'serif'],
-  ['Palatino-BoldItalic', 'Palatino Linotype', 'bold', null, 'italic', 'serif'],
-  ['Palatino-Italic', 'Palatino Linotype', null, null, 'italic', 'serif'],
-  ['Palatino-Roman', 'Palatino Linotype', 'roman', null, null, 'serif'],
-  ['Symbol', 'Symbol', null, null, null, 'fantasy'],
-  ['Times-Bold', 'Times', 'bold', null, null, 'serif'],
-  ['Times-BoldItalic', 'Times', 'bold', null, 'italic', 'serif'],
-  ['Times-Italic', 'Times', null, null, 'italic', 'serif'],
-  ['Times-Roman', 'Times', null, null, null, 'serif'],
-  ['ZapfChancery-MediumItalic', 'URW Chancery L', 'medium', null, 'italic', 'serif'],
-  ['ZapfDingbats', 'Dingbats', null, null, null, 'fantasy'],
+  ['AvantGarde-Book', 'URW Gothic L', 'book', null, null, 'sans-Serif', null, null],
+  ['AvantGarde-BookOblique', 'URW Gothic L', 'book', null, 'oblique', 'sans-Serif', null, 'italic'],
+  ['AvantGarde-Demi', 'URW Gothic L', 'demi', null, null, 'sans-Serif', 'bold', null],
+  ['AvantGarde-DemiOblique', 'URW Gothic L', 'demi', null, 'oblique', 'sans-Serif', 'bold', 'italic'],
+  ['Bookman-Demi', 'URW Bookman L', 'demi', null, null, 'serif', 'bold', null],
+  ['Bookman-DemiItalic', 'URW Bookman L', 'demi', null, 'italic', 'serif', 'bold', 'italic'],
+  ['Bookman-Light', 'URW Bookman L', 'light', null, null, 'serif', null, null],
+  ['Bookman-LightItalic', 'URW Bookman L', 'light', null, 'italic', 'serif', null, 'italic'],
+  ['Courier', 'Courier', null, null, null, 'monospace', null, null],
+  ['Courier-Bold', 'Courier', 'bold', null, null, 'monospace', 'bold', null],
+  ['Courier-BoldOblique', 'Courier', 'bold', null, 'oblique', 'monospace', 'bold', 'italic'],
+  ['Courier-Oblique', 'Courier', null, null, 'oblique', 'monospace', null, 'italic'],
+  ['Helvetica', 'Helvetica', null, null, null, 'sans-Serif', null, null],
+  ['Helvetica-Bold', 'Helvetica', 'bold', null, null, 'sans-Serif', 'bold', null],
+  ['Helvetica-BoldOblique', 'Helvetica', 'bold', null, 'oblique', 'sans-Serif', 'bold', 'italic'],
+  ['Helvetica-Narrow', 'Helvetica', null, 'condensed', null, 'sans-Serif', null, null],
+  ['Helvetica-Narrow-Bold', 'Helvetica', 'bold', 'condensed', null, 'sans-Serif', 'bold', null],
+  ['Helvetica-Narrow-BoldOblique', 'Helvetica', 'bold', 'condensed', 'oblique', 'sans-Serif', 'bold', 'italic'],
+  ['Helvetica-Narrow-Oblique', 'Helvetica', null, 'condensed', 'oblique', 'sans-Serif', null, 'italic'],
+  ['Helvetica-Oblique', 'Helvetica', null, null, 'oblique', 'sans-Serif', null, 'italic'],
+  ['NewCenturySchlbk-Bold', 'Century Schoolbook L', 'bold', null, null, 'serif', 'bold', null],
+  ['NewCenturySchlbk-BoldItalic', 'Century Schoolbook L', 'bold', null, 'italic', 'serif', 'bold', 'italic'],
+  ['NewCenturySchlbk-Italic', 'Century Schoolbook L', null, null, 'italic', 'serif', null, 'italic'],
+  ['NewCenturySchlbk-Roman', 'Century Schoolbook L', 'roman', null, null, 'serif', null, null],
+  ['Palatino-Bold', 'Palatino Linotype', 'bold', null, null, 'serif', 'bold', null],
+  ['Palatino-BoldItalic', 'Palatino Linotype', 'bold', null, 'italic', 'serif', 'bold', 'italic'],
+  ['Palatino-Italic', 'Palatino Linotype', null, null, 'italic', 'serif', null, 'italic'],
+  ['Palatino-Roman', 'Palatino Linotype', 'roman', null, null, 'serif', null, null],
+  ['Symbol', 'Symbol', null, null, null, 'fantasy', null, null],
+  ['Times-Bold', 'Times', 'bold', null, null, 'serif', 'bold', null],
+  ['Times-BoldItalic', 'Times', 'bold', null, 'italic', 'serif', 'bold', 'italic'],
+  ['Times-Italic', 'Times', null, null, 'italic', 'serif', null, 'italic'],
+  ['Times-Roman', 'Times', null, null, null, 'serif', null, null],
+  ['ZapfChancery-MediumItalic', 'URW Chancery L', 'medium', null, 'italic', 'serif', null, 'italic'],
+  ['ZapfDingbats', 'Dingbats', null, null, null, 'fantasy', null, null],
 ];
 
 const ALIAS_BY_NAME: ReadonlyMap<string, PostscriptAlias> = new Map(
   ALIAS_ROWS.map((r) => [
     r[0].toLowerCase(),
-    { family: r[1], weight: r[2], stretch: r[3], style: r[4], svgFontFamily: r[5] },
+    {
+      name: r[0], family: r[1], weight: r[2], stretch: r[3], style: r[4],
+      svgFontFamily: r[5], svgFontWeight: r[6], svgFontStyle: r[7],
+    },
   ]),
 );
 
@@ -89,24 +100,44 @@ export function translatePostscriptFontname(name: string): PostscriptAlias | nul
 
 /**
  * Build the SVG font attribute string for a span's font name when it resolves
- * to a PostScript alias: ` font-family="family[,svgFontFamily]"` plus the
- * alias's weight/stretch/style. Returns null when there is no alias (the caller
- * emits the name verbatim). `weight`/`style` report whether the alias set them,
- * so the HTML-flag block can avoid duplicating bold/italic.
+ * to a PostScript alias, honouring the graph's `fontnames` mode. Returns null
+ * when there is no alias (the caller emits the name verbatim).
+ * `weight`/`style` report whether the alias set them, so the HTML-flag block
+ * can avoid duplicating bold/italic.
+ *
+ * C selects family/weight/style as a THREE-WAY switch on GD_fontnames, and the
+ * SVGFONTS branch reads different struct fields (svg_font_weight /
+ * svg_font_style) rather than reusing the native ones — so the mode changes
+ * more than the family string. The `,svgFontFamily` suffix is appended by the
+ * same rule in every mode: only when it differs from the chosen family, which
+ * is exactly why SVGFONTS emits a bare `sans-Serif` and NATIVEFONTS emits
+ * `Helvetica,sans-Serif`.
  *
  * Family strings contain no XML-special characters, so (like C's raw `%s`) no
  * escaping is applied here.
- * @see plugin/core/gvrender_core_svg.c:462-495 svg_textspan (NATIVEFONTS)
+ * @see plugin/core/gvrender_core_svg.c:462-495 svg_textspan
  */
 export function fontFamilyAttrs(
   fontName: string | null,
+  mode: FontnameKind = FontnameKind.NativeFonts,
 ): { attrs: string; weight: boolean; style: boolean } | null {
   const a = fontName !== null ? translatePostscriptFontname(fontName) : null;
   if (a === null) return null;
-  const fam = a.svgFontFamily !== a.family ? a.family + ',' + a.svgFontFamily : a.family;
+  let family: string;
+  let weight: string | null;
+  let style: string | null;
+  switch (mode) {
+    case FontnameKind.PsFonts:
+      family = a.name; weight = a.weight; style = a.style; break;
+    case FontnameKind.SvgFonts:
+      family = a.svgFontFamily; weight = a.svgFontWeight; style = a.svgFontStyle; break;
+    default:
+      family = a.family; weight = a.weight; style = a.style; break;
+  }
+  const fam = a.svgFontFamily !== family ? family + ',' + a.svgFontFamily : family;
   let attrs = ' font-family="' + fam + '"';
-  if (a.weight !== null) attrs += ' font-weight="' + a.weight + '"';
+  if (weight !== null) attrs += ' font-weight="' + weight + '"';
   if (a.stretch !== null) attrs += ' font-stretch="' + a.stretch + '"';
-  if (a.style !== null) attrs += ' font-style="' + a.style + '"';
-  return { attrs, weight: a.weight !== null, style: a.style !== null };
+  if (style !== null) attrs += ' font-style="' + style + '"';
+  return { attrs, weight: weight !== null, style: style !== null };
 }

package/src/common/splines-clip.ts

@@ -97,6 +97,22 @@ class SplineClipHelper {
     return [sflag, eflag];
   }
 
+  /**
+   * The ORIGINAL edge's arrow end whose TYPE applies at a geometric spline end.
+   *
+   * C resolves both arrow types once from the original edge (arrow_flags) and
+   * encodes each type in its flag, so swapping the two flags when swapEnds is
+   * true carries the type along with it. This port keeps only the presence bit
+   * in the flag and re-reads the type from the `arrowhead`/`arrowtail`
+   * attribute, so the same swap has to be applied to the NAME lookup — without
+   * it a reversed back edge (`C->A [arrowhead=tee]`, head ranked above tail)
+   * draws its `arrowtail` type at the end where C draws the arrowhead.
+   * @see lib/common/splines.c:arrow_clip (if (j) SWAP(sflag, eflag))
+   */
+  static arrowAttrEnd(isTail: boolean, j: boolean): 'head' | 'tail' {
+    return isTail !== j ? 'tail' : 'head';
+  }
+
   static resolveArrowFlags(info: SplineInfo, hn: Node, fe: Edge, orig: Edge, j: boolean): [number, number] {
     let [sflag, eflag] = SplineClipHelper.arrowFlags(orig);
     if (info.splineMerge != null) {
@@ -147,9 +163,10 @@ class SplineClipHelper {
    */
   static arrowEndClip(
     e: Edge, ps: Point[], startp: number, endpIn: number, spl: Bezier, eflag: number,
+    attrEnd: 'head' | 'tail' = 'head',
   ): number {
     let endp = endpIn;
-    const elen = arrowClipLength(edgeArrowName(e, 'head'),
+    const elen = arrowClipLength(edgeArrowName(e, attrEnd),
       SplineClipHelper.clipArrowsize(e), SplineClipHelper.clipPenwidth(e));
     spl.eflag = eflag;
     spl.ep = ps[endp + 3]!;
@@ -174,9 +191,10 @@ class SplineClipHelper {
    */
   static arrowStartClip(
     e: Edge, ps: Point[], startpIn: number, endp: number, spl: Bezier, sflag: number,
+    attrEnd: 'head' | 'tail' = 'tail',
   ): number {
     let startp = startpIn;
-    const slen = arrowClipLength(edgeArrowName(e, 'tail'),
+    const slen = arrowClipLength(edgeArrowName(e, attrEnd),
       SplineClipHelper.clipArrowsize(e), SplineClipHelper.clipPenwidth(e));
     spl.sflag = sflag;
     spl.sp = ps[startp]!;
@@ -231,24 +249,29 @@ class SplineClipHelper {
     newspl.eflag = eflag;
     // C: ortho edges use arrowOrthoClip (keeps segments axis-aligned), not the
     // De-Casteljau start/end clips. @see lib/common/splines.c:90
+    // The arrow TYPE follows the flag swap, not the geometric end: see
+    // arrowAttrEnd. (Under ortho, ignoreSwap forces j=false, so these are the
+    // plain tail/head ends.)
+    const startEnd = SplineClipHelper.arrowAttrEnd(true, j);
+    const endEnd = SplineClipHelper.arrowAttrEnd(false, j);
     if (info.isOrtho) {
       if (sflag || eflag) {
         SplineClipHelper.arrowOrthoClip(
           orig, ps, bounds.start, bounds.end, newspl, sflag, eflag);
-        if (sflag) SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true);
-        if (eflag) SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false);
+        if (sflag) SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true, startEnd);
+        if (eflag) SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
       }
       return;
     }
     if (sflag) {
       bounds.start = SplineClipHelper.arrowStartClip(
-        orig, ps, bounds.start, bounds.end, newspl, sflag);
-      SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true);
+        orig, ps, bounds.start, bounds.end, newspl, sflag, startEnd);
+      SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true, startEnd);
     }
     if (eflag) {
       bounds.end = SplineClipHelper.arrowEndClip(
-        orig, ps, bounds.start, bounds.end, newspl, eflag);
-      SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false);
+        orig, ps, bounds.start, bounds.end, newspl, eflag, endEnd);
+      SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
     }
   }
 
@@ -314,9 +337,12 @@ class SplineClipHelper {
   }
 
   /** Record an arrow polygon on the edge for svgArrowPolygons. */
-  static stashArrow(e: Edge, tip: Point, base: Point, isTail: boolean): void {
+  static stashArrow(
+    e: Edge, tip: Point, base: Point, isTail: boolean, attrEnd?: 'head' | 'tail',
+  ): void {
     const dir = { x: base.x - tip.x, y: base.y - tip.y };
-    const ops = arrowDrawOpsForEnd(e, isTail ? 'tail' : 'head', tip, dir, SplineClipHelper.renderPenwidth(e));
+    const end = attrEnd ?? (isTail ? 'tail' : 'head');
+    const ops = arrowDrawOpsForEnd(e, end, tip, dir, SplineClipHelper.renderPenwidth(e));
     if (isTail) e.info.tailArrowOps = ops;
     else e.info.headArrowOps = ops;
   }

package/src/gvc/device.ts

@@ -173,11 +173,19 @@ function nodeInBox(n: Node, job: RenderJob): boolean {
 function emitNodeBody(n: Node, renderer: RendererPlugin, job: RenderJob): void {
   setHtmlAnchorObj(svgNodeId(n, job), labelTextOf(n.info.label), job.obj ?? undefined);
   setHtmlObjImgscale(nodeAttr(n, n.root, 'imagescale'));
-  renderer.beginNode(n, job);
-  const shape = n.info.shape as ShapeDesc | undefined;
-  if (shape?.fns?.codefn) shape.fns.codefn(job, n);
-  renderNodeXLabel(n, renderer, job);
-  renderer.endNode(n, job);
+  // C sets the node's colorscheme at the tail of emit_begin_node and restores
+  // it at the head of emit_end_node, so the window spans codefn AND the xlabel
+  // — not just the color block. Bare scheme indices in the node's LABEL (e.g.
+  // `fontcolor=3` under `colorscheme=rdbu5`) resolve inside this window; with
+  // the window scoped to the fill/pen block they fell back to black.
+  // @see lib/common/emit.c:1781/1789 · emit_node:1826-1831
+  withColorScheme(nodeAttr(n, n.root, 'colorscheme'), () => {
+    renderer.beginNode(n, job);
+    const shape = n.info.shape as ShapeDesc | undefined;
+    if (shape?.fns?.codefn) shape.fns.codefn(job, n);
+    renderNodeXLabel(n, renderer, job);
+    renderer.endNode(n, job);
+  });
 }
 
 /**
@@ -193,8 +201,12 @@ export function renderNode(n: Node, renderer: RendererPlugin, job: RenderJob, do
   // "and is in page/view" gate. @see lib/common/emit.c:1808 node_in_box
   if (!nodeInBox(n, job)) return;
   // Shortcircuit invisible nodes: C omits the whole node before emit_begin_node.
+  // C reads late_string(n, N_style, ""), i.e. agxget — which resolves the
+  // node's DECLARATION-SCOPE default, so `{ node [style=invis] p q }` hides p
+  // and q. Reading n.attrs directly sees only a style set on the node itself
+  // and drew every subgraph-scoped invisible node (switch.gv: 16 of them).
   // @see lib/common/emit.c:emit_node (style "invis" return)
-  const nodeStyle = n.attrs.get('style');
+  const nodeStyle = nodeAttr(n, n.root, 'style');
   if (parseStyleFlags(nodeStyle).invis) return;
   // The "invisible" alias also suppresses drawing (gvrender_set_style →
   // PEN_NONE) for shapes that pass their raw style through — but NOT the point

package/src/gvc/job.ts

@@ -11,6 +11,7 @@
  */
 
 import type { Graph } from '../model/graph.js';
+import { FontnameKind } from '../model/layoutParams.js';
 import type { Node } from '../model/node.js';
 import type { Edge } from '../model/edge.js';
 import type { Point, Box } from '../model/geom.js';
@@ -297,6 +298,9 @@ export class RenderJob {
   radialGradId: number = 0;
   /** Whether the graph being rendered is directed (edge titles use -> vs --). */
   directed: boolean = true;
+  /** GD_fontnames of the root graph — selects which PostScript-alias fields the
+   *  SVG emitter uses. @see plugin/core/gvrender_core_svg.c:464 */
+  fontnames: FontnameKind = FontnameKind.NativeFonts;
   /** Root graph's `id` attribute (GD_drawing(root)->id), '' if unset. Used as
    * the `<gid>_` prefix for non-root object ids. @see lib/common/emit.c:getObjId */
   drawingId: string = '';

package/src/layout/dot/index.ts

@@ -164,10 +164,37 @@ export function dotPhasePost(g: Graph): void {
 // dotLayoutPipeline — the static dotLayout function from dotinit.c
 // ---------------------------------------------------------------------------
 
+/**
+ * How many pipeline phases to run: C's
+ * `late_int(g, agfindgraphattr(g, "phase"), -1, 1)`.
+ *
+ * The DOT attribute is `phase`; `maxphase` is only the name of C's local
+ * variable. The port read `maxphase` as the attribute name, so it responded to
+ * a name C ignores and ignored the one C honours — invisible to every parity
+ * track, because no corpus graph declares either (found via the attribute
+ * blind-spot scan, test/corpus/attr-frequency.ts).
+ *
+ * late_int's `minimum` argument is 1, and it clamps rather than rejects, so a
+ * present-but-smaller value becomes 1 — only an ABSENT or unparseable value
+ * yields the -1 "run everything" default.
+ * @see lib/dotgen/dotinit.c:297 · lib/common/utils.c:40 late_int
+ */
+function graphPhase(g: Graph): number {
+  const v = g.attrs.get('phase');
+  if (v === undefined || v === '') return -1;
+  // strtol parses a numeric PREFIX, so "3abc" is 3, and parseInt agrees. The
+  // two failure exits return defaultValue WITHOUT clamping, so `phase=abc`
+  // runs the whole pipeline while `phase=0` clamps up to 1 — the distinction
+  // getAttrInt cannot express, since it collapses both onto defaultVal.
+  const n = parseInt(v, 10);
+  if (isNaN(n) || n > 2147483647) return -1;
+  return n < 1 ? 1 : n;
+}
+
 /**
  * Runs the full dot layout pipeline on graph g.
  *
- * The optional `maxphase` attribute (read from g.attrs) controls how many
+ * The optional `phase` attribute (read from g.attrs) controls how many
  * phases run (1=rank only, 2=+mincross, 3=+position, ≥4 or absent=all).
  *
  * C's `dotLayout` checks `dot_mincross`'s return code and returns immediately
@@ -198,16 +225,21 @@ export function dotPhasePost(g: Graph): void {
  * where C produces near-empty output.
  */
 export function dotLayoutPipeline(g: Graph): void {
-  const maxphase = getAttrInt(g, 'maxphase', -1);
+  const maxphase = graphPhase(g);
   dotPhaseInit(g);
   dotRank(g);
-  if (maxphase === 1) return;
+  // A phase stop is a SUCCESS return in C (dotLayout returns 0), and
+  // `dot_layout` skips dotneato_postprocess only when doDot reports an ERROR
+  // (dotinit.c:512-517). So the postprocess still runs on every phase stop —
+  // without it the drawing keeps raw layout coordinates and is translated off
+  // the origin. The rc/posRc paths below are the error paths and stay bare.
+  if (maxphase === 1) { gvPostprocess(g); return; }
   const rc = dotMincross(g);
   if (rc !== 0) return;
-  if (maxphase === 2) return;
+  if (maxphase === 2) { gvPostprocess(g); return; }
   const posRc = dotPosition(g);
   if (posRc !== 0) return;
-  if (maxphase === 3) return;
+  if (maxphase === 3) { gvPostprocess(g); return; }
   dotPhasePost(g);
 }
 

package/src/layout/sfdp/init.ts

@@ -140,6 +140,17 @@ export function tuneControl(g: Graph, ctrl: SpringElectricalControl): void {
   ctrl.beautifyLeaves = mapBool(aggetGraph(g, 'beautify'), false);
   ctrl.doShrinking = mapBool(aggetGraph(g, 'overlap_shrink'), true);
   ctrl.rotation = lateDouble(aggetGraph(g, 'rotation'), 0.0, -Number.MAX_VALUE);
+  // C rotates the layout before overlap removal (spring_electrical.c:1181).
+  // `rotate()` is not ported, and nothing reads ctrl.rotation, so a non-zero
+  // value silently produced an UNROTATED layout — native moves nodes ~320pt on
+  // a 6-node graph at rotation=45. Fail the way `smoothing` above does: a loud
+  // unported-feature error beats silently wrong geometry.
+  // Found by the attribute blind-spot scan; no corpus graph sets it.
+  if (ctrl.rotation !== 0) {
+    throw new Error(
+      `sfdp rotation="${ctrl.rotation}": rotate() is not ported ` +
+      '(unreachable at sfdp defaults); see plans/port-catalog/README.md');
+  }
   ctrl.edgeLabelingScheme = lateInt(aggetGraph(g, 'label_scheme'), 0, 0);
   if (ctrl.edgeLabelingScheme > 4) ctrl.edgeLabelingScheme = 0;
 }

package/src/model/graph.ts

@@ -105,6 +105,32 @@ export class Graph {
    */
   graphDefaultsSnapshot?: Map<string, string>;
 
+  /**
+   * Keys in `attrs` the BUILDER seeded from `graphDefaultsSnapshot` rather than
+   * the input declaring them in this scope (see builder.ts GRAPH_LABEL_INHERIT_
+   * KEYS). cgraph distinguishes these structurally — a seeded value is inherited
+   * through the dict view and has no local symbol, while a local declaration
+   * creates one even when its value equals the inherited value — so the
+   * serializer needs the provenance to decide what write_dict would print.
+   * Undefined on the root graph and on any scope that seeded nothing.
+   * @see lib/cgraph/write.c:262 write_dict
+   */
+  seededAttrs?: Set<string>;
+
+  /**
+   * Graph-attribute keys whose declaration in THIS scope was the first anywhere
+   * in the graph. cgraph's `setattr` splits on exactly this: a key with no
+   * existing symbol takes the global-declaration branch, which ends up seeding
+   * every direct subgraph that already exists with a local empty value (see
+   * `eagerEmptyParts`); a key some earlier scope already declared takes the
+   * "new local definition" branch and touches no subgraph at all. So an
+   * identical `graph [fill=x]` statement makes a child print `fill=""` or print
+   * nothing purely according to whether a SIBLING declared `fill` first.
+   * Undefined on any scope that declared nothing new.
+   * @see lib/cgraph/attr.c:257 setattr (lsym / psym / global branches)
+   */
+  firstGraphDecl?: Set<string>;
+
   /**
    * Layout-engine info; replaces GD_* macros via agbindrec (AD-1).
    * @see lib/cgraph/cgraph.h:agbindrec