@knowvah/dot-engine 2.6.11 → 2.6.12

package/package.json

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

@@ -18,6 +18,7 @@ import type { EngineName } from '../gvc/context.js';
 import { createDefaultContext } from '../gvc/default-context.js';
 import { checkRenderArgs } from '../render/public.js';
 import { render as deviceRender } from '../gvc/device.js';
+import { resetRenderState } from '../common/render-state.js';
 import type { ImageSizer } from '../common/htmltable-types.js';
 import type { ImageResolver } from '../gvc/image-resolver.js';
 import type { OutputFormat, RenderOptions } from '../render/public.js';
@@ -148,6 +149,11 @@ export async function renderAsync(
   const engine: EngineName = opts?.engine ?? 'dot';
   try {
     const { fontIssues, sizes, bytes } = await prefetchAll(g, opts);
+    // AD-4: reset after the last await, so the synchronous layout + render
+    // below starts from C's initial process state even when other renders ran
+    // while the prefetch was pending. renderSvgAsync and renderSvgInto reach
+    // this through renderAsync.
+    resetRenderState();
     // Created after fonts settle so the measurer sees the loaded faces.
     const ctx = createDefaultContext();
     if (opts?.imageSizer !== undefined) {

package/src/common/agerr.ts

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * The one stderr writer for messages C prints through cgraph's agerr family
+ * (`agerr`, `agerrorf`, `agwarningf`, `AGPREV` continuations). Sites whose C
+ * counterpart is `fprintf(stderr)`/`fputs`/`printf` do not use it.
+ */
+
+import { registerRenderState } from './render-state.js';
+
+/** `agerrlevel_t` as the port uses it: AGERR, AGWARN, AGPREV. */
+export type AgerrLevel = 'error' | 'warning' | 'prev';
+
+/** The console channel a line goes to. */
+export type AgerrChannel = 'warn' | 'error';
+
+const PREFIX_ERROR = 'Error';
+const PREFIX_WARNING = 'Warning';
+const PREFIX_SEP = ': ';
+const DEL = 0x7f;
+const LAST_CNTRL = 0x1f;
+const WHITESPACE = new Set([0x09, 0x0a, 0x0b, 0x0c, 0x0d]);
+const OCTAL_WIDTH = 3;
+const OCTAL_RADIX = 8;
+
+/**
+ * The level of the last non-AGPREV message, which AGPREV continues: C's
+ * `agerrno`, zero-initialised, i.e. AGWARN. Reset per render (AD-4).
+ * @see lib/cgraph/agerror.c:agerrno
+ */
+let lastLevel: 'error' | 'warning' = 'warning';
+
+registerRenderState(() => {
+  lastLevel = 'warning';
+});
+
+/**
+ * `default_usererrf`: every character that `gv_iscntrl(c) && !gv_isspace(c)`
+ * (0x00-0x1F except `\t\n\v\f\r`, and 0x7F) is written as `\ooo`.
+ * @see lib/cgraph/agerror.c:default_usererrf
+ */
+export function escapeControl(message: string): string {
+  let out = '';
+  for (const ch of message) {
+    const c = ch.codePointAt(0)!;
+    if ((c <= LAST_CNTRL || c === DEL) && !WHITESPACE.has(c)) {
+      out += `\\${c.toString(OCTAL_RADIX).padStart(OCTAL_WIDTH, '0')}`;
+    } else out += ch;
+  }
+  return out;
+}
+
+/**
+ * Write one already-assembled stderr line (prefix included) on a console
+ * channel, escaped as `default_usererrf` would.
+ */
+export function agerrLineOn(channel: AgerrChannel, line: string): void {
+  if (channel === 'warn') console.warn(escapeControl(line));
+  else console.error(escapeControl(line));
+}
+
+/**
+ * The part of C's `agerr(level, ...)` that is not formatting: the `Error: `/
+ * `Warning: ` prefix (none for AGPREV), escaping, and the console channel
+ * (`console.warn` for warnings, `console.error` otherwise; AGPREV continues
+ * the previous level's channel).
+ * @see lib/cgraph/agerror.c:out
+ */
+export function agerr(level: AgerrLevel, msg: string, channel?: AgerrChannel): void {
+  if (level === 'prev') {
+    agerrLineOn(channel ?? (lastLevel === 'warning' ? 'warn' : 'error'), msg);
+    return;
+  }
+  lastLevel = level;
+  const prefix = level === 'error' ? PREFIX_ERROR : PREFIX_WARNING;
+  agerrLineOn(channel ?? (level === 'warning' ? 'warn' : 'error'), `${prefix}${PREFIX_SEP}${msg}`);
+}
+
+/** @see lib/cgraph/agerror.c:agerrorf */
+export const agerrorf = (msg: string, channel?: AgerrChannel): void => agerr('error', msg, channel);
+
+/**
+ * @see lib/cgraph/agerror.c:agwarningf
+ * `channel` overrides the console channel for sites that have always written
+ * their warning on `console.error`.
+ */
+export const agwarningf = (msg: string, channel?: AgerrChannel): void =>
+  agerr('warning', msg, channel);
+
+/**
+ * A finished line whose prefix is already part of the text. The channel
+ * follows the prefix (`Warning` -> `console.warn`) unless `channel` is given.
+ */
+export function agerrFinished(line: string, channel?: AgerrChannel): void {
+  agerrLineOn(channel ?? (line.startsWith(PREFIX_WARNING) ? 'warn' : 'error'), line);
+}

package/src/common/arrows-shapes-poly.ts

@@ -11,6 +11,7 @@
 import type { Point } from '../model/geom.js';
 import { ccwrotatepf, cwrotatepf } from '../model/geom.js';
 import { bezier } from './bezier.js';
+import { fma } from './fma.js';
 import type { GenResult } from './arrows-shapes-util.js';
 import {
   vsub, vadd, miterShape, negUnit, backwardDelta, axialProjection,
@@ -206,14 +207,27 @@ function cubicHalf(c: Point[], rightHalf: boolean): Point[] {
   return half;
 }
 
-/** Build the four Bézier control points for the curve arms. */
+/**
+ * Build the four Bézier control points for the curve arms.
+ *
+ * The oracle (libgvc 16.1 `_arrow_type_curve`) contracts only the
+ * `p.x +/- 0.95 * v.x` term into `fmadd(v.x, +/-0.95, p.x)`; every other add
+ * is a plain fadd, and `w.x * 4.0 / 3.0` is `(w.x * 4) / 3` (fmul, fdiv).
+ * Only the x arms carry the 0.95 term, so AF[1].y / AF[2].y stay unfused.
+ * @see lib/common/arrows.c:arrow_type_curve
+ */
 function curveControlPoints(p: Point, v: Point, w: Point, flag: number): Point[] {
   const AF0: Point = { x: p.x + v.x + w.x, y: p.y + v.y + w.y };
   const AF3: Point = { x: p.x - v.x + w.x, y: p.y - v.y + w.y };
-  const s = flag & ARR_MOD_INV ? 1 : -1; // inv bulges the curve the other way
-  const AF1: Point = { x: p.x + 0.95 * v.x + w.x + s * w.x * (4.0 / 3.0), y: AF0.y + s * w.y * (4.0 / 3.0) };
-  const AF2: Point = { x: p.x - 0.95 * v.x + w.x + s * w.x * (4.0 / 3.0), y: AF3.y + s * w.y * (4.0 / 3.0) };
-  return [AF0, AF1, AF2, AF3];
+  const bulgeX = (w.x * 4.0) / 3.0;
+  const bulgeY = (w.y * 4.0) / 3.0;
+  const x1 = fma(v.x, 0.95, p.x) + w.x;
+  const x2 = fma(v.x, -0.95, p.x) + w.x;
+  if (flag & ARR_MOD_INV) { /* ----(-| */
+    return [AF0, { x: x1 + bulgeX, y: AF0.y + bulgeY }, { x: x2 + bulgeX, y: AF3.y + bulgeY }, AF3];
+  }
+  /* ----)-| */
+  return [AF0, { x: x1 - bulgeX, y: AF0.y - bulgeY }, { x: x2 - bulgeX, y: AF3.y - bulgeY }, AF3];
 }
 
 /** @see lib/common/arrows.c:arrow_type_curve */

package/src/common/color.ts

@@ -7,6 +7,7 @@
 
 import { isExactlyEqual } from '../util/math.js';
 import { COLOR_LIB } from './colorData.js';
+import { registerRenderState } from './render-state.js';
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -37,6 +38,7 @@ interface HsvaTuple { H: number; S: number; V: number; A: number }
 // ---------------------------------------------------------------------------
 
 let colorScheme: string = '';
+registerRenderState(() => { colorScheme = ''; });
 
 /** @see lib/common/colxlate.c:setColorScheme */
 export function setColorScheme(scheme: string): void {
@@ -256,17 +258,43 @@ function setBlackOpaque(color: GVColor, targetType: ColorType): void {
 // Hex and HSV string parsers
 // ---------------------------------------------------------------------------
 
-/** Parse "#rrggbb", "#rrggbbaa", or "#rgb". Returns null on failure. */
+/** C isspace in the "C" locale. */
+const SSCANF_SPACE = new Set([' ', '\t', '\n', '\v', '\f', '\r']);
+
+/**
+ * `sscanf(p, "#" + "%<width>x" * max)`: the values converted before the first
+ * failure. Each `%x` skips leading white space then takes up to `width` hex
+ * digits, so a short or odd-length run still converts ("#12345" gives 0x12,
+ * 0x34, 0x5). Sign and `0x` prefixes are not modelled.
+ * @see lib/common/colxlate.c:colorxlate
+ */
+function scanHexGroups(p: string, width: number, max: number): number[] {
+  const out: number[] = [];
+  if (p.charAt(0) !== '#') return out;
+  let i = 1;
+  while (out.length < max) {
+    while (SSCANF_SPACE.has(p.charAt(i))) i++;
+    let j = i;
+    while (j < p.length && j - i < width && /[0-9a-fA-F]/.test(p.charAt(j))) j++;
+    if (j === i) break;
+    out.push(parseInt(p.slice(i, j), 16));
+    i = j;
+  }
+  return out;
+}
+
+/**
+ * Parse "#rrggbb", "#rrggbbaa" (any run of at least three two-digit groups),
+ * or the 4-character "#rgb" form, as colorxlate's sscanf calls do. Returns
+ * null on failure.
+ */
 function parseHexColor(p: string): RgbaTuple | null {
-  if (p.charAt(0) !== '#') return null;
-  const m8 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(p);
-  if (m8) return { r: parseInt(m8[1], 16), g: parseInt(m8[2], 16), b: parseInt(m8[3], 16), a: parseInt(m8[4], 16) };
-  const m6 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(p);
-  if (m6) return { r: parseInt(m6[1], 16), g: parseInt(m6[2], 16), b: parseInt(m6[3], 16), a: 255 };
-  const m3 = /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/.exec(p);
-  if (!m3) return null;
-  const r = parseInt(m3[1], 16); const g = parseInt(m3[2], 16); const b = parseInt(m3[3], 16);
-  return { r: r | (r << 4), g: g | (g << 4), b: b | (b << 4), a: 255 };
+  const g = scanHexGroups(p, 2, 4);
+  if (g.length >= 3) return { r: g[0]!, g: g[1]!, b: g[2]!, a: g[3] ?? 255 };
+  const short = p.length === 4 ? scanHexGroups(p, 1, 3) : [];
+  if (short.length !== 3) return null;
+  const [r, gg, b] = short as [number, number, number];
+  return { r: r | (r << 4), g: gg | (gg << 4), b: b | (b << 4), a: 255 };
 }
 
 /** Clamp a number to [0, 1]. */

package/src/common/crand.ts

@@ -21,11 +21,17 @@
  * @see lib/util/random.c:gv_random / gv_permutation (15.0.0)
  */
 
+import { registerRenderState } from './render-state.js';
+
 /** RAND_MAX on the reference platform. */
 export const C_RAND_MAX = 2147483647;
 
-/** Current stream state; unseeded C rand() behaves as srand(1). */
-let state = 1;
+/** Unseeded C rand() behaves as srand(1). */
+const UNSEEDED_STATE = 1;
+
+/** Current stream state. */
+let state = UNSEEDED_STATE;
+registerRenderState(() => { state = UNSEEDED_STATE; });
 
 /** srand(3). */
 export function csrand(seed: number): void {

package/src/common/emit-once.ts

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Once-per-process message gate. C keeps the seen strings in a file static
+ * dictionary that is cleared only by `emit_once_reset` in `gvFreeContext`; one
+ * native run is one process, so the port clears it per render (AD-4).
+ *
+ * @see lib/common/emit.c:emit_once
+ */
+
+import { registerRenderState } from './render-state.js';
+
+const seen = new Set<string>();
+
+registerRenderState(() => {
+  seen.clear();
+});
+
+/**
+ * True the first time `str` is offered since the last reset, false after.
+ * @see lib/common/emit.c:emit_once
+ */
+export function emitOnce(str: string): boolean {
+  if (seen.has(str)) return false;
+  seen.add(str);
+  return true;
+}

package/src/common/graph-init.ts

@@ -29,6 +29,7 @@ import type { RatioKind } from '../model/layoutParams.js';
 import { doGraphLabel } from '../layout/dot/graph-label.js';
 import { mapbool, setClType, LOCAL, GLOBAL, NOCLUST } from '../layout/dot/rank.js';
 import { cround } from './arith.js';
+import { agwarningf } from './agerr.js';
 
 // ---------------------------------------------------------------------------
 // Constants — @see lib/common/const.h
@@ -88,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;
-  console.error(`Warning: Unsupported charset "${raw}" - assuming utf-8`);
+  agwarningf(`Unsupported charset "${raw}" - assuming utf-8`, 'error');
   return CHAR_UTF8;
 }
 

package/src/common/htmltable-attr-warn.ts

@@ -11,6 +11,8 @@
  * @see lib/common/htmllex.c:doAttrs
  */
 
+import { agerrFinished } from './agerr.js';
+
 /** An attribute as startElement gets it: name in source case, value decoded by expat. */
 export type AttrEntry = readonly [name: string, value: string];
 
@@ -272,10 +274,7 @@ export class StderrLines {
 }
 
 /** A finished stderr line on the console channel the port uses for it. */
-export const consoleLine = (line: string): void => {
-  if (line.startsWith('Warning')) console.warn(line);
-  else console.error(line);
-};
+export const consoleLine = (line: string): void => agerrFinished(line);
 
 /** One label's stderr: what make_html_label and make_label print, in order. */
 export const labelStderr = (): StderrLines => new StderrLines(consoleLine);

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

@@ -18,6 +18,7 @@ import { FillType, PenType } from '../gvc/context.js';
 import { transformPoint } from '../gvc/device.js';
 import { 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 {
   BORDER_LEFT,
@@ -26,6 +27,7 @@ import {
   BORDER_BOTTOM,
   BORDER_MASK,
 } from './htmltable-types.js';
+import { registerRenderState } from './render-state.js';
 
 // ---------------------------------------------------------------------------
 // Gradient spec parser
@@ -136,6 +138,7 @@ export function htmlFillPenWidth(): number {
 export function resetHtmlFillPenWidth(): void {
   htmlFillPen = 1.0;
 }
+registerRenderState(resetHtmlFillPenWidth);
 
 /** Map an HTML STYLE to the C pen type: dashed wins over dotted. @see lib/common/htmltable.c:doBorder */
 function penTypeOf(style: string | undefined): PenType {
@@ -366,3 +369,48 @@ function emitSidedPolylines(
     renderer.polyline(seq.map((i) => corners[i]!), job);
   }
 }
+
+// ---------------------------------------------------------------------------
+// htmlLabelColors — the colour names C resolves while emitting an HTML label
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/const.h DEFAULT_COLOR */
+const HTML_DEFAULT_COLOR = 'black';
+
+/** setFill's names: the fill (and a gradient's stop). @see htmltable.c:setFill */
+function bgNames(bgcolor: string): string[] {
+  const spec = parseGradientSpec(bgcolor);
+  return spec === null ? [bgcolor] : [spec[0], spec[1]];
+}
+
+/** One cell in emit_html_cell order: fill, border, then the child. */
+function cellNames(cell: PlacedCell): string[] {
+  if (htmlStyle(cell.style).invisible) return [];
+  const out = cell.bgcolor !== undefined ? bgNames(cell.bgcolor) : [];
+  if (cell.border > 0) out.push(cell.color ?? HTML_DEFAULT_COLOR);
+  if (cell.nested !== undefined) out.push(...tableNames(cell.nested));
+  else for (const line of cell.lines) if (line.fontColor !== null) out.push(line.fontColor);
+  return out;
+}
+
+/** One table in emit_html_tbl order: fill, rules, border, cells. */
+function tableNames(tbl: PlacedHtml): string[] {
+  if (htmlStyle(tbl.style).invisible) return [];
+  const out = tbl.bgcolor !== undefined ? bgNames(tbl.bgcolor) : [];
+  const color = tbl.color ?? HTML_DEFAULT_COLOR;
+  if (tbl.cells.some((c) => c.vruled === true || c.hruled === true)) out.push(color);
+  if (tbl.border > 0) out.push(color);
+  for (const cell of tbl.cells) out.push(...cellNames(cell));
+  return out;
+}
+
+/**
+ * The names an HTML label hands to gvrender_resolve_color, in C's order: the
+ * root table's pen first (emit_html_label), then emit_html_tbl's walk.
+ * @see lib/common/htmltable.c:emit_html_label
+ * @see lib/common/htmltable.c:emit_html_tbl
+ * @see lib/common/htmltable.c:emit_html_cell
+ */
+export function htmlLabelColors(label: PlacedHtml): string[] {
+  return [label.color ?? HTML_DEFAULT_COLOR, ...tableNames(label)];
+}

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

@@ -14,6 +14,7 @@ import type { RenderJob } from '../gvc/job.js';
 import type { RendererPlugin } from '../gvc/context.js';
 import type { PlacedCell, PlacedHtml } from './htmltable-pos.js';
 import { doSide, withHtmlPaint } from './htmltable-emit-fill.js';
+import { registerRenderState } from './render-state.js';
 
 // ---------------------------------------------------------------------------
 // Rule context
@@ -217,6 +218,7 @@ export function resetHtmlAnchorIds(): void {
   anchorEnv.objLabel = null;
   anchorEnv.imgscale = 'false';
 }
+registerRenderState(resetHtmlAnchorIds);
 
 /**
  * Open an anchor when the data carries href/title/target.

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

@@ -270,12 +270,19 @@ function scanCdata(text: string, p: number, base: number, dataOf: CdataText, tok
   return close < 0 ? -1 : close + CDATA_CLOSE.length;
 }
 
-/** Character data at `p` up to the next `<`: one `text` token, then the index it ends at. */
-function scanText(text: string, p: number, base: number, tokens: ExpatToken[]): number {
+/**
+ * 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)
+ */
+function scanText(text: string, p: number, base: number, tokens: ExpatToken[]): { at: number; held: boolean } {
   const e = text.indexOf('<', p);
-  const end = e < 0 ? text.length : e;
-  tokens.push({ kind: 'text', start: base + p, end: base + end });
-  return end;
+  const slice = text.slice(p, e < 0 ? text.length : e);
+  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 });
+  return { at: end, held: from !== undefined };
 }
 
 /** The fed text of the label source between two offsets. */
@@ -295,7 +302,9 @@ function scanContent(text: string, base: number, inCdata: boolean, dataOf: Cdata
       continue;
     }
     if (text[p] !== '<') {
-      p = scanText(text, p, base, tokens);
+      const scanned = scanText(text, p, base, tokens);
+      if (scanned.held) return { tokens, consumed: scanned.at, inCdata: false };
+      p = scanned.at;
       continue;
     }
     const { scan, kind } = scanMarkup(text, p);
@@ -408,33 +417,79 @@ export class ExpatFeed {
 /** Entities expat knows without a DTD; `scanEntity` leaves them as written. */
 const XML_PREDEFINED_ENTITIES = new Set(['lt', 'gt', 'amp', 'quot', 'apos']);
 
-const ENTITY_NAME = /^[A-Za-z_:][\w.:-]*$/;
+/** An `&name;` that `scanEntity` rewrites: 2 to 8 characters (alphanumeric) that name an HTML entity. */
+const SCANNED_ENTITY = /^&([^;&<]*);/;
+
+/**
+ * The reference the content tokenizer reads at the `&` at `t`: the index after
+ * its `;`, or the index of the character that makes it an invalid token (the
+ * end of `text` when the reference runs out: `</HTML>` or another tag follows).
+ * Runs the attribute value scanner over the reference alone, closed by a quote,
+ * which is scanRef on the same bytes.
+ * @see expat lib/xmltok_impl.c:PREFIX(contentTok) (BT_AMP)
+ * @see expat lib/xmltok_impl.c:PREFIX(scanRef)
+ * @see expat lib/xmltok_impl.c:PREFIX(scanCharRef)
+ * @see expat lib/xmltok_impl.c:PREFIX(scanHexCharRef)
+ */
+function contentRef(text: string, t: number): { end: number } | { invalid: number } {
+  const semi = text.indexOf(';', t);
+  const ref = text.slice(t, semi < 0 ? text.length : semi + 1);
+  const scan = scanAttValue(`"${ref}"`, 0);
+  if ('close' in scan) return { end: t + scan.close - 1 };
+  return { invalid: 'invalid' in scan ? t + scan.invalid - 1 : text.length };
+}
 
-const CHAR_REF = /^&#(?:x[0-9A-Fa-f]+|[0-9]+);/;
+/** A reference problem of character data: expat's error, where its event pointer is, and the `&` it began at. */
+interface RefProblem {
+  message: string;
+  offset: number;
+  from: number;
+}
 
 /**
- * The first reference of character data that expat rejects, at its offset: a
- * `&name;` scanEntity leaves alone (neither an HTML entity nor predefined), or
- * a character reference XML does not allow.
- * @see expat lib/xmlparse.c:doContent (XML_TOK_ENTITY_REF, XML_TOK_CHAR_REF)
+ * The first reference of character data that expat rejects: an invalid token
+ * (a bare `&`, `&#;`, `&#X41;`, `&#65q`, ..), a `&name;` scanEntity leaves
+ * alone (neither an HTML entity nor predefined), or a character reference XML
+ * does not allow. An invalid token at the very end of `text` is a reference
+ * expat is still waiting on.
+ * @see lib/common/utils.c:scanEntity
+ * @see expat lib/xmlparse.c:doContent (XML_TOK_INVALID, XML_TOK_ENTITY_REF, XML_TOK_CHAR_REF)
  */
-export function textRefError(text: string): { message: string; offset: number } | undefined {
-  for (let t = text.indexOf('&'); t >= 0; t = text.indexOf('&', t + 1)) {
-    if (text[t + 1] === '#') {
-      const ref = CHAR_REF.exec(text.slice(t))?.[0];
-      if (ref !== undefined && charRefNumber(ref) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: t };
-      continue;
+function firstRefProblem(text: string): RefProblem | undefined {
+  let t = text.indexOf('&');
+  while (t >= 0) {
+    if (text[t + 1] !== '#') {
+      const name = SCANNED_ENTITY.exec(text.slice(t))?.[1];
+      if (name !== undefined && name.length >= 2 && Object.hasOwn(HTML_ENTITIES, name)) {
+        t = text.indexOf('&', t + name.length + 2);
+        continue;
+      }
     }
-    const semi = text.indexOf(';', t + 1);
-    if (semi < 0) continue;
-    const key = text.slice(t + 1, semi);
-    if (ENTITY_NAME.test(key) && !Object.hasOwn(HTML_ENTITIES, key) && !XML_PREDEFINED_ENTITIES.has(key)) {
-      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t };
+    const ref = contentRef(text, t);
+    if ('invalid' in ref) return { message: XML_ERROR_INVALID_TOKEN, offset: ref.invalid, from: t };
+    const key = text.slice(t + 1, ref.end - 1);
+    if (text[t + 1] === '#') {
+      if (charRefNumber(`&${key};`) < 0) return { message: XML_ERROR_BAD_CHAR_REF, offset: t, from: t };
+    } else if (!XML_PREDEFINED_ENTITIES.has(key)) {
+      return { message: XML_ERROR_UNDEFINED_ENTITY, offset: t, from: t };
     }
+    t = text.indexOf('&', ref.end);
   }
   return undefined;
 }
 
+/** The first reference of character data that expat rejects, and the offset of its event pointer. */
+export function textRefError(text: string): { message: string; offset: number } | undefined {
+  const problem = firstRefProblem(text);
+  return problem === undefined ? undefined : { message: problem.message, offset: problem.offset };
+}
+
+/** Where a reference that runs to the end of `text` begins: expat holds it until more data arrives. */
+function heldRefStart(text: string): number | undefined {
+  const problem = firstRefProblem(text);
+  return problem?.message === XML_ERROR_INVALID_TOKEN && problem.offset === text.length ? problem.from : undefined;
+}
+
 export interface TagChunk {
   close: boolean;
   selfClose: boolean;

package/src/common/htmltable.ts

@@ -169,25 +169,24 @@ const itemHasFlags = (i: HtmlTextItem): boolean =>
   i.subscript === true || i.superscript === true;
 
 /**
- * C's "simple" test: one item per line, no font flags, uniform
- * resolved face and size across all lines.
+ * 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)
  */
-export const htmlTextIsSimple = (texts: HtmlText[], env: HtmlSizeEnv): boolean => {
+const htmlTextIsSimple = (lines: SizedLine[], env: HtmlSizeEnv): boolean => {
   let prevFs = -1;
   let prevFace: string | null = null;
-  let count = 0;
-  for (const txt of texts) {
-    for (const item of txt.items) {
-      if (item.br) { count = 0; continue; }
-      if (item.text === undefined) continue;
-      if (++count > 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;
-    }
+  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;
 };
@@ -203,7 +202,7 @@ const sizeTextContent = (
   env: HtmlSizeEnv = defaultSizeEnv(),
 ): { w: number; h: number } => {
   const lines = splitSizedLines(texts, measurer, env);
-  const simple = htmlTextIsSimple(texts, env);
+  const simple = htmlTextIsSimple(lines, env);
   let w = 0;
   let h = 0;
   for (const ln of lines) {

package/src/common/poly-gencode.ts

@@ -33,7 +33,8 @@ import {
   styleTokens,
 } from './style-resolve.js';
 import { stripedBox, wedgedEllipse } from '../render/svg-multicolor.js';
-import { resolveRenderColor } from '../render/color-resolve.js';
+import { resolveRenderColor, reportColorNames } from '../render/color-resolve.js';
+import { htmlLabelColors } from './htmltable-emit-fill.js';
 import { svgNodeId } from '../render/svg-id.js';
 import { drawRoundCorners, mcircleHack, underlineDraw } from './poly-shapes.js';
 
@@ -191,6 +192,8 @@ export function renderLabel(
   job: RenderJob,
 ): void {
   if (label.u.kind !== 'txt' || label.u.nspans < 1) return;
+  // gvrender_set_pencolor(job, lp->fontcolor), once, before the spans.
+  reportColorNames([label.fontcolor]);
   label.pos = coord;
   label.set = true;
   // First-span baseline per valign (labelloc). @see lib/common/labels.c:240-251
@@ -227,6 +230,7 @@ function renderNodeLabel(
     // Route the HTML label's box/fill/text ops into the node LABEL emit-state
     // (→ _ldraw_ for xdot), not the node DRAW state. SVG ignores emit_state.
     const html = label.u.html as PlacedHtml;
+    reportColorNames(htmlLabelColors(html));
     withLabelEmitState(job, () => emitHtmlLabel(html, coord, renderer, job));
   } else {
     renderLabel(label, coord, renderer, job);
@@ -367,8 +371,16 @@ export function applyNodeStyle(obj: ObjState, n: Node, job: RenderJob): boolean
   // 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 penwidth = nodeAttr(n, n.root, 'penwidth');
+  // record_gencode resolves the pen (penColor) before the fill; poly_gencode
+  // and point_gencode resolve the fill first. Only the order in which an
+  // unknown colour is reported differs. @see shapes.c:3890-3892 vs 2985-3004
+  if ((n.info.shape as ShapeDesc | undefined)?.kind === ShapeKind.SH_RECORD) {
+    applyPenState(obj, styleAttr, colorAttr, penwidth);
+    return applyFillState(obj, n, job);
+  }
   const filled = applyFillState(obj, n, job);
-  applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, 'penwidth'));
+  applyPenState(obj, styleAttr, colorAttr, penwidth);
   return filled;
 }