@knowvah/dot-engine 2.6.12 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.6.12",
+  "version": "2.7.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/attr-get.ts

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Attribute reads with cgraph's `agxget` semantics: an object's own value,
+ * else the declared default it was created under. A leaf module (model types
+ * only) so label and shape code can share it without an import cycle.
+ *
+ * @see lib/cgraph/attr.c:agxget
+ */
+
+import type { Node } from '../model/node.js';
+import type { Graph } from '../model/graph.js';
+
+/**
+ * Read a node attribute: the node's own value, else the node-attribute defaults
+ * (`node [...]`) captured from the node's declaring scope up to root *at the
+ * time the node was created*. The snapshot makes a `node [...]` declared after
+ * the node — at any scope — correctly not apply, and lets a cluster-scoped
+ * default reach nodes declared in that cluster, as the oracle does.
+ *
+ * Programmatically created nodes have no snapshot; they fall back to the live
+ * defaults of the passed graph `g` and root.
+ * @see lib/cgraph/attr.c:agxget; src/parser/builder.ts:effectiveNodeDefaults
+ */
+export function nodeAttr(n: Node, g: Graph, key: string): string | undefined {
+  const own = n.attrs.get(key);
+  if (own !== undefined) return own;
+  if (n.nodeDefaultsSnapshot !== undefined) return n.nodeDefaultsSnapshot.get(key);
+  return g.nodeDefaults.get(key)
+    ?? (g !== g.root ? g.root.nodeDefaults.get(key) : undefined);
+}
+
+/**
+ * Read a graph attribute with subgraph→root inheritance, mirroring C's
+ * agxget (late_nnstring(sg, agfindgraphattr(sg, key), ...) in do_graph_label):
+ * a cluster inherits `fontname`/`fontsize`/`fontcolor` set on an ancestor
+ * (e.g. root `graph[fontname=Arial]`) when it sets none of its own.
+ * @see lib/common/input.c:do_graph_label
+ */
+export function graphAttrInherited(sg: Graph, key: string): string | undefined {
+  // Own value wins; otherwise the ancestor defaults SNAPSHOTTED when this
+  // subgraph opened (not a live parent walk) — so an ancestor attribute set
+  // later in statement order does not retroactively apply (2184).
+  // @see lib/cgraph/graph.c:agsubg (parse-time defval copy)
+  return sg.attrs.get(key) ?? sg.graphDefaultsSnapshot?.get(key);
+}

package/src/common/graph-init.ts

@@ -89,7 +89,7 @@ export function findCharset(g: Graph): number {
   }
   if (p === 'big-5' || p === 'big5') return CHAR_BIG5;
   if (p === 'utf-8' || p === 'utf8') return CHAR_UTF8;
-  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`, 'error');
+  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`);
   return CHAR_UTF8;
 }
 

package/src/common/htmltable-emit-fill.ts

@@ -16,10 +16,11 @@ import { ObjType, EmitState, MapShape } from '../gvc/job.js';
 import type { RendererPlugin } from '../gvc/context.js';
 import { FillType, PenType } from '../gvc/context.js';
 import { transformPoint } from '../gvc/device.js';
-import { resolveRenderColor } from '../render/color-resolve.js';
+import { firstColor, resolveRenderColor } from '../render/color-resolve.js';
 import { emitRoundedBezier } from './poly-shapes.js';
 import type { PlacedHtml, PlacedCell } from './htmltable-pos.js';
 import { htmlStyle } from './htmltable-style.js';
+import { gvrenderSetStyle } from '../gvc/gvrender-set-style.js';
 import {
   BORDER_LEFT,
   BORDER_TOP,
@@ -27,25 +28,54 @@ import {
   BORDER_BOTTOM,
   BORDER_MASK,
 } from './htmltable-types.js';
+import { parseSegs, parseSegsSilent } from './multicolor.js';
+import { agwarningf } from './agerr.js';
 import { registerRenderState } from './render-state.js';
 
 // ---------------------------------------------------------------------------
 // Gradient spec parser
 // ---------------------------------------------------------------------------
 
+/** The colours and fraction findStopColor yields; `stop` null → DEFAULT_COLOR. */
+export interface HtmlStopColor {
+  fill: string;
+  stop: string | null;
+  frac: number;
+}
+
+/** @see lib/common/emit.c:findStopColor */
+const MSG_MANY_COLORS = 'More than 2 colors specified for a gradient - ignoring remaining';
+
+/**
+ * Port of C's findStopColor over parseSegs: null when parseSegs returns
+ * non-zero (including the rv 3 over-full warning), has < 2 segments or has no
+ * first colour. `silent` skips every diagnostic (port-internal pre-passes);
+ * otherwise parseSegs' once-per-render messages and the more-than-2-colours
+ * warning print as C does (no AGPREV context).
+ *
+ * @see lib/common/emit.c:findStopColor
+ */
+export function findHtmlStopColor(color: string, silent = false): HtmlStopColor | null {
+  const { segs, error } = silent ? parseSegsSilent(color) : parseSegs(color);
+  const first = segs[0];
+  const second = segs[1];
+  if (error !== 0 || first === undefined || second === undefined || first.color === null) {
+    return null;
+  }
+  if (segs.length > 2 && !silent) agwarningf(MSG_MANY_COLORS);
+  const frac = first.hasFraction ? first.t : second.hasFraction ? 1 - second.t : 0;
+  return { fill: first.color, stop: second.color, frac };
+}
+
 /**
- * Parse a color spec for gradient: "color1:color2" → [color1, color2].
- * Single-color strings return null (not a gradient spec).
+ * [fill, stop] of a colour-list gradient spec, or null for a solid colour.
+ * Silent {@link findHtmlStopColor} for call sites that only need the colours.
  *
  * @see lib/common/emit.c:findStopColor
  */
 export function parseGradientSpec(color: string): [string, string] | null {
-  const idx = color.indexOf(':');
-  if (idx < 1) return null;
-  const c0 = color.slice(0, idx).trim();
-  const c1 = color.slice(idx + 1).trim();
-  if (c0.length === 0) return null;
-  return [c0, c1.length > 0 ? c1 : 'black'];
+  const spec = findHtmlStopColor(color, true);
+  return spec === null ? null : [spec.fill, spec.stop ?? 'black'];
 }
 
 // ---------------------------------------------------------------------------
@@ -104,6 +134,8 @@ export interface HtmlPaint {
    * C setFill's findStopColor hit. @see lib/common/htmltable.c:setFill
    */
   stop?: string;
+  /** findStopColor's fraction; defaults to 0. Ignored without `stop`. */
+  gradientFrac?: number;
   /** Gradient angle in degrees; defaults to 0. Ignored without `stop`. */
   gradientAngle?: number;
   /** True → radial gradient (RGRADIENT); else linear. Ignored without `stop`. */
@@ -141,6 +173,16 @@ export function resetHtmlFillPenWidth(): void {
 registerRenderState(resetHtmlFillPenWidth);
 
 /** Map an HTML STYLE to the C pen type: dashed wins over dotted. @see lib/common/htmltable.c:doBorder */
+/** gvc->defaultlinestyle. @see lib/common/emit.c:105 */
+const DEFAULT_LINE_STYLE: readonly string[] = ['solid', 'setlinewidth(1)'];
+
+/** The style list doBorder hands to gvrender_set_style for a pen type. */
+function htmlBorderStyle(pen: PenType): readonly string[] {
+  if (pen === PenType.Dashed) return ['dashed'];
+  if (pen === PenType.Dotted) return ['dotted'];
+  return DEFAULT_LINE_STYLE;
+}
+
 function penTypeOf(style: string | undefined): PenType {
   const st = htmlStyle(style);
   if (st.dashed) return PenType.Dashed;
@@ -156,7 +198,7 @@ function penTypeOf(style: string | undefined): PenType {
  */
 export function withHtmlPaint(paint: HtmlPaint, job: RenderJob, drawFn: () => void): void {
   paintObj.fillColor = paint.fill !== undefined
-    ? resolveRenderColor(paint.fill) : { type: 'none' };
+    ? resolveRenderColor(firstColor(paint.fill)) : { type: 'none' };
   paintObj.penColor = paint.pen !== undefined
     ? resolveRenderColor(paint.pen) : { type: 'string', s: 'transparent' };
   applyHtmlFill(paint);
@@ -166,6 +208,9 @@ export function withHtmlPaint(paint: HtmlPaint, job: RenderJob, drawFn: () => vo
   // so xdot emits `S 5 -solid` per border/fill. rawStyle carries it (SVG's
   // style emit treats "solid" as the default → no visible change).
   paintObj.rawStyle = paintObj.pen === PenType.Solid ? ['solid'] : [];
+  // emit_html_tbl/cell border: dashed or dotted by name, else defaultlinestyle.
+  // @see lib/common/htmltable.c:267 doBorder
+  gvrenderSetStyle(htmlBorderStyle(paintObj.pen));
   // Inherit the enclosing object's emit-state (the label state during an HTML
   // label emit) so the fill/border ops route to the same xbuf as the label
   // (_ldraw_), not the shape draw buffer. SVG ignores emit_state, so unchanged.
@@ -186,7 +231,7 @@ function applyHtmlFill(paint: HtmlPaint): void {
     paintObj.fill = paint.radial === true ? FillType.Radial : FillType.Linear;
     paintObj.stopColor = resolveRenderColor(paint.stop);
     paintObj.gradientAngle = paint.gradientAngle ?? 0;
-    paintObj.gradientFrac = 0;
+    paintObj.gradientFrac = paint.gradientFrac ?? 0;
     return;
   }
   paintObj.fill = paint.fill !== undefined ? FillType.Solid : FillType.None;

package/src/common/htmltable-emit.ts

@@ -31,7 +31,7 @@ import type { PlacedHtml, PlacedCell, PlacedLine, PlacedImage } from './htmltabl
 import { transformPoint } from '../gvc/device.js';
 import { gvrenderTextspan } from '../gvc/textspan-emit.js';
 import {
-  withHtmlPaint, parseGradientSpec, doBorder, mkPts,
+  withHtmlPaint, findHtmlStopColor, doBorder, mkPts,
   htmlFillPenWidth, resetHtmlFillPenWidth, type HtmlPaint,
 } from './htmltable-emit-fill.js';
 import { emitRoundedBezier } from './poly-shapes.js';
@@ -121,10 +121,11 @@ function bgFillPaint(ctx: BgFillCtx): HtmlPaint {
   // penWidth = the leaked gvrender pen width (prior doBorder); a bordered cell's
   // fill carries it as stroke-width even with stroke="none". @see htmltable.c:setFill
   const penWidth = htmlFillPenWidth();
-  const spec = parseGradientSpec(ctx.bgcolor);
+  const spec = findHtmlStopColor(ctx.bgcolor);
   if (spec === null) return { fill: ctx.bgcolor, penWidth };
   return {
-    fill: spec[0], stop: spec[1], gradientAngle: ctx.gradientangle ?? 0,
+    fill: spec.fill, stop: spec.stop ?? 'black', gradientFrac: spec.frac,
+    gradientAngle: ctx.gradientangle ?? 0,
     radial: htmlStyle(ctx.style).radial, penWidth,
   };
 }

package/src/common/htmltable-lex-expat.ts

@@ -270,15 +270,32 @@ function scanCdata(text: string, p: number, base: number, dataOf: CdataText, tok
   return close < 0 ? -1 : close + CDATA_CLOSE.length;
 }
 
+/**
+ * A character expat's tokenizer rejects in character data (BT_NONXML in the
+ * UTF-8 table): controls other than tab, LF and CR, U+FFFE and U+FFFF, and a
+ * lone surrogate (the UTF-8 form of one is invalid). DEL is BT_OTHER, valid.
+ * @see expat lib/asciitab.h
+ * @see expat lib/xmltok_impl.c:PREFIX(contentTok) (BT_NONXML)
+ */
+const CONTENT_NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+
 /**
  * Character data at `p` up to the next `<`: one `text` token, then the index it
  * ends at. A reference cut off by the end of the data is not part of the token
- * (`held`): expat waits for the characters that settle it.
- * @see expat lib/xmltok_impl.c:PREFIX(contentTok) (XML_TOK_PARTIAL)
+ * (`held`): expat waits for the characters that settle it. A BT_NONXML character
+ * ends the data token; the next call finds it an invalid token (`invalid`).
+ * @see expat lib/xmltok_impl.c:PREFIX(contentTok) (XML_TOK_PARTIAL, BT_NONXML)
  */
-function scanText(text: string, p: number, base: number, tokens: ExpatToken[]): { at: number; held: boolean } {
+function scanText(
+  text: string, p: number, base: number, tokens: ExpatToken[],
+): { at: number; held: boolean; invalid?: number } {
   const e = text.indexOf('<', p);
   const slice = text.slice(p, e < 0 ? text.length : e);
+  const bad = CONTENT_NON_XML.exec(slice)?.index;
+  if (bad !== undefined) {
+    if (bad > 0) tokens.push({ kind: 'text', start: base + p, end: base + p + bad });
+    return { at: p + bad, held: false, invalid: p + bad };
+  }
   const from = e < 0 ? heldRefStart(slice) : undefined;
   const end = from === undefined ? p + slice.length : p + from;
   if (end > p) tokens.push({ kind: 'text', start: base + p, end: base + end });
@@ -303,6 +320,7 @@ function scanContent(text: string, base: number, inCdata: boolean, dataOf: Cdata
     }
     if (text[p] !== '<') {
       const scanned = scanText(text, p, base, tokens);
+      if (scanned.invalid !== undefined) return { tokens, consumed: scanned.at, invalid: base + scanned.invalid, inCdata: false };
       if (scanned.held) return { tokens, consumed: scanned.at, inCdata: false };
       p = scanned.at;
       continue;

package/src/common/htmltable-pos-runs.ts

@@ -48,7 +48,10 @@ export interface HtmlFontInfo {
   fontcolor: string;
 }
 
-interface LineRun {
+/** The label font defaults the line builder needs (sizing env or placement finfo). */
+export type LabelFont = Pick<HtmlFontInfo, 'fontname' | 'fontsize'>;
+
+export interface LineRun {
   items: HtmlTextItem[];
   width: number;
   /** Max raw font size over items (C mxfsize). */
@@ -84,7 +87,7 @@ export function itemFontFlags(item: HtmlTextItem): number {
 }
 
 /** Resolved face/size for an item, defaulting to the inherited finfo. */
-function itemFace(item: HtmlTextItem, finfo: HtmlFontInfo): { fs: number; face: string } {
+function itemFace(item: HtmlTextItem, finfo: LabelFont): { fs: number; face: string } {
   return {
     fs: item.fontSize !== undefined ? item.fontSize : finfo.fontsize,
     face: item.fontFace !== undefined ? item.fontFace : finfo.fontname,
@@ -95,7 +98,7 @@ function itemFace(item: HtmlTextItem, finfo: HtmlFontInfo): { fs: number; face:
 interface ItemMetric { w: number; h: number; fs: number; yoffsetCenterline?: number; yoffsetLayout?: number; }
 
 /** Measure one text item; null when the item carries no text. */
-function measureItem(item: HtmlTextItem, finfo: HtmlFontInfo, measurer: TextMeasurer): ItemMetric | null {
+function measureItem(item: HtmlTextItem, finfo: LabelFont, measurer: TextMeasurer): ItemMetric | null {
   if (item.text === undefined) return null;
   const { fs, face } = itemFace(item, finfo);
   const flags = itemFontFlags(item);
@@ -142,11 +145,13 @@ function accumulateItem(cur: LineRun, item: HtmlTextItem, m: ItemMetric): void {
  *   in the current font (consecutive BRs = a real blank line with height);
  * - at end of text a line is added ONLY if items remain — a trailing BR does
  *   NOT create a phantom empty line (this over-sized e.g. html2's node c).
+ * The single builder: size_html_txt (sizing) and emit_htextspans (placement)
+ * both read these runs, as C reads one htextspan_t list.
  * @see lib/common/htmlparse.y:appendFLineList / mkText
  */
 export function buildLineRuns(
   texts: HtmlText[],
-  finfo: HtmlFontInfo,
+  finfo: LabelFont,
   measurer: TextMeasurer,
 ): LineRun[] {
   const runs: LineRun[] = [];
@@ -181,7 +186,7 @@ export function buildLineRuns(
  */
 function runSimpleKey(
   run: LineRun,
-  finfo: HtmlFontInfo,
+  finfo: LabelFont,
 ): { fs: number; face: string } | null | undefined {
   if (run.items.length > 1) return null;
   const item = run.items[0];
@@ -195,7 +200,7 @@ function runSimpleKey(
  * uniform resolved face/size across lines.
  * @see lib/common/htmltable.c:size_html_txt (lines 946-986)
  */
-export function runsAreSimple(runs: LineRun[], finfo: HtmlFontInfo): boolean {
+export function runsAreSimple(runs: LineRun[], finfo: LabelFont): boolean {
   let prevFs = -1;
   let prevFace: string | null = null;
   for (const run of runs) {

package/src/common/htmltable.ts

@@ -20,11 +20,13 @@ export type { TextMeasurer } from './textmeasure.js';
 
 import type {
   HtmlCell, HtmlCellContent, HtmlImage, HtmlLabel, HtmlTable, HtmlText,
-  HtmlTextItem, ImageSizer,
+  ImageSizer,
 } from './htmltable-types.js';
-import { findImageSize } from '../gvc/usershape.js';
+import { findImageSize, imageIsSupplied, imageOpenWarning } from '../gvc/usershape.js';
+import { registerRenderState } from './render-state.js';
 import { PointSet } from './pointset.js';
 import type { TextMeasurer } from './textmeasure.js';
+import { buildLineRuns, runsAreSimple } from './htmltable-pos-runs.js';
 import { withTableFont } from './htmltable-fontinfo.js';
 import { agerrLine, type StderrLines } from './htmltable-attr-warn.js';
 
@@ -90,107 +92,6 @@ export interface HtmlSizeEnv {
 
 const defaultSizeEnv = (): HtmlSizeEnv => ({ fontsize: DEFAULT_FONTSIZE, fontname: '' });
 
-/** One measured text line (a C "span"). @see size_html_txt */
-interface SizedLine {
-  items: HtmlTextItem[];
-  width: number;
-  /** Max metric line height over items (C mxysize). */
-  mxysize: number;
-  /** Max raw font size over items (C mxfsize). */
-  mxfsize: number;
-}
-
-const itemFont = (item: HtmlTextItem, env: HtmlSizeEnv): { fs: number; face: string } => ({
-  fs: item.fontSize !== undefined ? item.fontSize : env.fontsize,
-  face: item.fontFace !== undefined ? item.fontFace : env.fontname,
-});
-
-const measureItem = (
-  item: HtmlTextItem,
-  measurer: TextMeasurer,
-  env: HtmlSizeEnv,
-): { w: number; h: number } => {
-  const { fs, face } = itemFont(item, env);
-  // Variant widths per run flags. @see lib/common/htmltable.c:size_html_txt
-  const flags = (item.bold === true || item.italic === true)
-    ? { bold: item.bold === true, italic: item.italic === true }
-    : undefined;
-  return measurer.measure(item.text ?? '', face, fs, flags);
-};
-
-/**
- * Split items into measured lines at <BR/>, mirroring C's parser exactly
- * (htmlparse.y appendFLineList/mkText): a BR with no accumulated items yields
- * a line with one empty-string item in the current font (consecutive BRs = a
- * real blank line with height); at end of text a line is added ONLY if items
- * remain — a trailing BR does NOT create a phantom empty line. Must stay in
- * lockstep with buildLineRuns (htmltable-pos-runs.ts), the placement twin.
- * @see lib/common/htmlparse.y:appendFLineList / mkText
- * @see lib/common/htmltable.c:size_html_txt
- */
-const splitSizedLines = (
-  texts: HtmlText[],
-  measurer: TextMeasurer,
-  env: HtmlSizeEnv,
-): SizedLine[] => {
-  const lines: SizedLine[] = [];
-  let cur: SizedLine = { items: [], width: 0, mxysize: 0, mxfsize: 0 };
-  const accumulate = (item: HtmlTextItem): void => {
-    const sz = measureItem(item, measurer, env);
-    cur.items.push(item);
-    cur.width += sz.w;
-    cur.mxysize = Math.max(cur.mxysize, sz.h);
-    cur.mxfsize = Math.max(cur.mxfsize, itemFont(item, env).fs);
-  };
-  const flush = (br?: HtmlTextItem): void => {
-    if (cur.items.length === 0 && br !== undefined) {
-      // C: empty fitemList on a BR → one ""-item span in the current font.
-      const { br: _b, brAlign: _a, ...fontProps } = br;
-      accumulate({ text: '', ...fontProps });
-    }
-    lines.push(cur);
-    cur = { items: [], width: 0, mxysize: 0, mxfsize: 0 };
-  };
-  for (const txt of texts) {
-    for (const item of txt.items) {
-      if (item.br) { flush(item); continue; }
-      if (item.text === undefined) continue;
-      accumulate(item);
-    }
-    if (cur.items.length > 0) flush(); // C mkText: only when items remain
-  }
-  return lines;
-};
-
-/** Does an item carry any font flag (C textfont_t.flags)? */
-const itemHasFlags = (i: HtmlTextItem): boolean =>
-  i.bold === true || i.italic === true || i.underline === true ||
-  i.strikethrough === true || i.overline === true ||
-  i.subscript === true || i.superscript === true;
-
-/**
- * C's "simple" test over the line list (C spans): one item per line, no font
- * flags, uniform resolved face and size across all lines. It reads each
- * line's first item, so the "" item appendFLineList gives an empty <BR/> line
- * counts with its font: `k<U><BR/><BR/></U>` is not simple.
- * @see lib/common/htmltable.c:size_html_txt (lines 946-986)
- */
-const htmlTextIsSimple = (lines: SizedLine[], env: HtmlSizeEnv): boolean => {
-  let prevFs = -1;
-  let prevFace: string | null = null;
-  for (const ln of lines) {
-    // splitSizedLines never yields an itemless line (C: nitems >= 1).
-    const item = ln.items[0]!;
-    if (ln.items.length > 1 || itemHasFlags(item)) return false;
-    const { fs, face } = itemFont(item, env);
-    if (prevFs < 0) prevFs = fs;
-    else if (fs !== prevFs) return false;
-    if (prevFace === null) prevFace = face;
-    else if (face !== prevFace) return false;
-  }
-  return true;
-};
-
 /**
  * Size a text block. C: per line lsize = mxysize when simple, else the
  * raw max font size (mxfsize); a single-line block always uses mxysize.
@@ -201,16 +102,17 @@ const sizeTextContent = (
   measurer: TextMeasurer,
   env: HtmlSizeEnv = defaultSizeEnv(),
 ): { w: number; h: number } => {
-  const lines = splitSizedLines(texts, measurer, env);
-  const simple = htmlTextIsSimple(lines, env);
+  // The one line builder, shared with placement (htmltable-pos-runs.ts).
+  const lines = buildLineRuns(texts, env, measurer);
+  const simple = runsAreSimple(lines, env);
   let w = 0;
   let h = 0;
   for (const ln of lines) {
     w = Math.max(w, ln.width);
-    const lsize = simple ? ln.mxysize : ln.mxfsize;
+    const lsize = simple ? ln.height : ln.fontSize;
     h += ln.items.length > 0 ? lsize : DEFAULT_FONTSIZE;
   }
-  if (lines.length === 1) h = lines[0]!.items.length > 0 ? lines[0]!.mxysize : DEFAULT_FONTSIZE;
+  if (lines.length === 1) h = lines[0]!.items.length > 0 ? lines[0]!.height : DEFAULT_FONTSIZE;
   return { w, h };
 };
 
@@ -228,25 +130,28 @@ const sizeTextContent = (
  * @see lib/common/htmltable.c:size_html_img (line 1080)
  */
 /** Images whose sizing failed: size_html_img's rv = 1 on every later call. */
-const missingImages = new WeakSet<HtmlImage>();
+const missingImages = { set: new WeakSet<HtmlImage>() };
 
 const sizeHtmlImg = (img: HtmlImage, { imageSizer, stderr }: HtmlSizeEnv): number => {
   // C sizes each image once (processTbl); the port's size and pos passes
   // share layoutHtmlTable, so guard against re-sizing (and re-warning). The
   // returned rv still follows C on every call.
-  if (img.width !== undefined && img.height !== undefined) return missingImages.has(img) ? 1 : 0;
+  if (img.width !== undefined && img.height !== undefined) return missingImages.set.has(img) ? 1 : 0;
   const sz = imageSizer !== undefined ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
     img.width = sz.w; img.height = sz.h;
     return 0;
   }
-  // Missing-image: zero size + warning.
+  // Missing-image: gvusershape_open's warning (unless bytes are supplied),
+  // then zero size + the Error.
+  // @see lib/gvc/gvusershape.c:gvusershape_file_access
+  if (!imageIsSupplied(img.src, imageSizer)) agerrLine(stderr, `Warning: ${imageOpenWarning(img.src)}`);
   // C: agerrorf("No or improper image file=\"%s\"\n", img->src) — agerr
   // prefixes "Error: " on stderr.
   agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
-  missingImages.add(img);
+  missingImages.set.add(img);
   return 1;
 };
 
@@ -317,7 +222,14 @@ const WARN_TABLE_UNSPECIFIED = 'Warning: fixed table size with unspecified width
  * C sizes each cell/table exactly once; the port's size and pos passes both
  * run layoutHtmlTable, so the size warnings are emitted on first sight only.
  */
-const sizeWarned = new WeakSet<object>();
+const sizeWarned = { set: new WeakSet<object>() };
+
+// Native re-parses per run, so each render starts with both sets empty (AD-7);
+// a WeakSet cannot be cleared, so the holder's field is swapped.
+registerRenderState(() => {
+  missingImages.set = new WeakSet<HtmlImage>();
+  sizeWarned.set = new WeakSet<object>();
+});
 
 /**
  * FIXED_FLAG branch of size_html_cell: C's rv (set at the warning sites; the
@@ -357,8 +269,8 @@ const getCellSize = (
   // @see lib/common/htmltable.c:size_html_cell (FIXED_FLAG branch + box.UR MAX)
   let szx = cw + margin;
   let szy = ch + margin;
-  const warn = !sizeWarned.has(cell);
-  sizeWarned.add(cell);
+  const warn = !sizeWarned.set.has(cell);
+  sizeWarned.set.add(cell);
   const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) { szx = 0; szy = 0; }
@@ -504,8 +416,8 @@ export const layoutHtmlTable = (
  * @see lib/common/htmltable.c:size_html_tbl (:1683, :1689)
  */
 const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }, out: StderrLines | undefined): number => {
-  const warn = !sizeWarned.has(tbl);
-  sizeWarned.add(tbl);
+  const warn = !sizeWarned.set.has(tbl);
+  sizeWarned.set.add(tbl);
   if (tbl.fixedsize !== true) return 0;
   if (tbl.width && tbl.height) {
     if (tbl.width >= dims.wd && tbl.height >= dims.ht) return 0;

package/src/common/libm-trig.ts

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * `cos`/`sin` as the native build host's libm computes them, at the only
+ * inputs Graphviz feeds with constant arguments: the corner angles
+ * 2π·(i ∓ 0.5)/8 of neatosplines.c's circumscribed ellipse 8-gon.
+ *
+ * V8's Math.sin/Math.cos are not correctly rounded everywhere, and the
+ * result depends on the CPU: at 9π/8 Node 22-26 on arm64 return
+ * -0.3826834323650896 (x64 and Node 20 return the correctly rounded value)
+ * where the reference libm (macOS arm64 libSystem) returns -0.38268343236508967.
+ * The ulp moves an obstacle corner off its node's centre line, which flips
+ * knife-edge triangulations in the multispline router. The table holds the
+ * host values for those nine angles (printed with `%a` by a clang -O2
+ * harness of the same expression, which also reproduces the oracle's
+ * makeObstacle vertices); any other input falls back to Math.cos/Math.sin.
+ *
+ * @see lib/neatogen/neatosplines.c:circumscribed_polygon_corner_about_ellipse
+ * @see docs/known-divergences.md (host libm)
+ */
+
+/** angle → [cos, sin] from the host libm, angles 2π·(k + 0.5)/8, k = -1..7. */
+const OCTAGON_TRIG: ReadonlyMap<number, readonly [number, number]> = new Map([
+  [-0.39269908169872414, [0.9238795325112867, -0.3826834323650898]],
+  [0.39269908169872414, [0.9238795325112867, 0.3826834323650898]],
+  [1.1780972450961724, [0.38268343236508984, 0.9238795325112867]],
+  [1.9634954084936207, [-0.3826834323650897, 0.9238795325112867]],
+  [2.748893571891069, [-0.9238795325112867, 0.3826834323650899]],
+  [3.5342917352885173, [-0.9238795325112868, -0.38268343236508967]],
+  [4.319689898685965, [-0.38268343236509034, -0.9238795325112865]],
+  [5.105088062083414, [0.38268343236509, -0.9238795325112866]],
+  [5.890486225480862, [0.9238795325112865, -0.3826834323650904]],
+] as const);
+
+/** libm `cos(x)` of the native build host (table above, else Math.cos). */
+export function libmCos(x: number): number {
+  return OCTAGON_TRIG.get(x)?.[0] ?? Math.cos(x);
+}
+
+/** libm `sin(x)` of the native build host (table above, else Math.sin). */
+export function libmSin(x: number): number {
+  return OCTAGON_TRIG.get(x)?.[1] ?? Math.sin(x);
+}

package/src/common/make-label.ts

@@ -16,6 +16,8 @@ import { makeHtmlLabelTo } from './htmltable-label.js';
 import { labelStderr } from './htmltable-attr-warn.js';
 import { substObj, type GraphObj } from './subst.js';
 import { Edge } from '../model/edge.js';
+import { Node } from '../model/node.js';
+import { nodeAttr, graphAttrInherited } from './attr-get.js';
 import { Graph } from '../model/graph.js';
 import { htmlEntityUTF8 } from './html-entities.js';
 
@@ -33,17 +35,27 @@ export { htmlEntityUTF8 };
 /**
  * The object's pen color: `pencolor` attr, else `color` attr, else undefined
  * (no default). An HTML table/cell border with no explicit COLOR inherits it.
+ * Read as C's agget does, so declared defaults count: a node's `node [...]`
+ * snapshot and a subgraph's inherited graph attributes (894589). Edge
+ * defaults are already materialized into `attrs` by the builder.
  * @see lib/common/htmltable.c:getPenColor
  */
 function getPenColor(obj?: GraphObj): string | undefined {
   if (obj === undefined) return undefined;
-  const pc = obj.attrs.get('pencolor');
+  const pc = aggetObj(obj, 'pencolor');
   if (pc !== undefined && pc !== '') return pc;
-  const c = obj.attrs.get('color');
+  const c = aggetObj(obj, 'color');
   if (c !== undefined && c !== '') return c;
   return undefined;
 }
 
+/** `agget(obj, key)` for any object kind. @see lib/cgraph/attr.c:agxget */
+function aggetObj(obj: GraphObj, key: string): string | undefined {
+  if (obj instanceof Node) return nodeAttr(obj, obj.root, key);
+  if (obj instanceof Graph) return graphAttrInherited(obj, key);
+  return obj.attrs.get(key);
+}
+
 /** The root graph owning `obj` (edges resolve through their tail node). */
 function rootOf(obj: GraphObj): Graph {
   return obj instanceof Edge ? obj.tail.root : obj.root;