@knowvah/dot-engine 2.6.10 → 2.6.12

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;
 }
 

package/src/common/poly-init.ts

@@ -24,6 +24,7 @@ import {
   DEFAULT_COLOR,
 } from './make-label.js';
 import { computeVertices } from './poly-vertices.js';
+import { agwarningf } from './agerr.js';
 
 // Default half-dimensions in points (72 dpi, 0.75 in wide, 0.5 in tall)
 const DEFAULT_LW = 27;
@@ -117,7 +118,7 @@ export function polyInit(n: Node, g: Graph, measurer: TextMeasurer): void {
   // C warns when the custom shape's image cannot be sized (headless: always).
   // @see lib/common/shapes.c:2027-2033
   if (shapefile !== undefined && shapefile !== '' && shapeName !== 'epsf') {
-    console.error(`Warning: No or improper shapefile="${shapefile}" for node "${n.name}"`);
+    agwarningf(`No or improper shapefile="${shapefile}" for node "${n.name}"`, 'error');
   }
   if ((n.info.shape as ShapeDesc).kind === ShapeKind.SH_RECORD) {
     if (n.info.shape_info === undefined) recordNodeInit(n, g, measurer);

package/src/common/postproc.ts

@@ -26,6 +26,8 @@ import {
   RANKDIR_TB, RANKDIR_LR, RANKDIR_BT, RANKDIR_RL,
 } from '../layout/dot/init.js';
 import { addXLabels } from './xlabels-place.js';
+import { registerRenderState } from './render-state.js';
+import { agerrLineOn } from './agerr.js';
 
 /** Concentrated multi-edge duplicate — never drawn. @see lib/common/const.h:IGNORED */
 const IGNORED_EDGE = 6;
@@ -38,6 +40,7 @@ const IGNORED_EDGE = 6;
 
 let Rankdir = 0;
 let Offset: Point = { x: 0, y: 0 };
+registerRenderState(() => { Rankdir = 0; Offset = { x: 0, y: 0 }; });
 
 /** The bezier fields map_edge reads/writes. */
 type MappedBezier = Pick<Bezier, 'list' | 'sflag' | 'eflag' | 'sp' | 'ep' | 'sArrowOps' | 'eArrowOps'>;
@@ -226,7 +229,7 @@ function translateDrawing(g: Graph): void {
       // @see lib/common/postproc.c:map_edge ("lost %s %s edge")
       if (e.info.spl === undefined) {
         if (!(g.info.concentrate ?? false) && (e.info.edge_type ?? 0) !== IGNORED_EDGE) {
-          console.warn(`lost ${e.tail.name} ${e.head.name} edge`);
+          agerrLineOn('warn', `lost ${e.tail.name} ${e.head.name} edge`);
         }
         continue;
       }

package/src/common/random.ts

@@ -14,12 +14,22 @@
  * @see lib/neatogen/neatoinit.c:checkStart (srand48 call)
  */
 
+import { registerRenderState } from './render-state.js';
+
 const A = BigInt('0x5deece66d');
 const C = BigInt('0xb');
 const MASK48 = (1n << 48n) - 1n;
 const TWO48 = 2 ** 48;
+/**
+ * Unseeded generator state: libc's X0 = 0x1234ABCD330E (rand48 seed words
+ * 0x1234, 0xABCD, 0x330E); verified on the reference machine — an unseeded
+ * drand48() returns 0.39646477376027534.
+ * @see POSIX drand48(3)
+ */
+const UNSEEDED_STATE = 0x1234abcd330en;
 
-let state = 0x330en; // POSIX default: X0 = 0x1234ABCD330E... see srand48 note
+let state = UNSEEDED_STATE;
+registerRenderState(() => { state = UNSEEDED_STATE; });
 
 /**
  * Seed the generator: X = (seed << 16) | 0x330E (low 32 bits of seed).

package/src/common/render-state.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Per-render scope for C process-level state (AD-4).
+ *
+ * Native Graphviz renders one graph per `dot` process, so every file static —
+ * RNG streams, sequence counters, the emit_once warning set — starts each
+ * graph at its C initial value (and gvFreeContext's emit_once_reset clears the
+ * warning set). The port's module statics outlive a render, so each module
+ * owning such state registers a reset that restores its C initial value, and
+ * every public render entry calls {@link resetRenderState} before any other
+ * work. Render output is then a function of its input alone.
+ *
+ * Not registered here: caller-installed hooks (setTextMeasurer,
+ * setImageSizer, setImageResolver) and debug hooks — they are configuration,
+ * not C process state.
+ *
+ * @see lib/gvc/gvcontext.c:gvFreeContext (emit_once_reset)
+ * @see lib/common/emit.c:emit_once_reset
+ */
+
+/** Registered resets, run in registration (module evaluation) order. */
+const resets: Array<() => void> = [];
+
+/**
+ * Register a reset restoring one module's C process state to its initial
+ * value. Called once, at module evaluation.
+ */
+export function registerRenderState(reset: () => void): void {
+  resets.push(reset);
+}
+
+/** Restore every registered module's C process state; call first per render. */
+export function resetRenderState(): void {
+  for (const reset of resets) reset();
+}

package/src/common/splines-geom.ts

@@ -10,6 +10,7 @@
 
 import type { Point, Box } from '../model/geom.js';
 import { bezier as evalBezier } from './bezier.js';
+import { fma } from './fma.js';
 
 // ---------------------------------------------------------------------------
 // Approximate equality
@@ -47,16 +48,19 @@ const HW = 2.0;
 const SMALL = 0.0000000001;
 
 /**
- * Distance from point p to line a-b, squared.
+ * Distance from point p to line a-b, squared. Native (arm64, clang
+ * -ffp-contract=on) fuses the numerator as fmadd(p.y-a.y, dx, -(dy*(p.x-a.x)))
+ * and the denominator as fmadd(dx, dx, dy*dy): libgvc _ptToLine2 at
+ * 0x21214-0x21244, identically in inlined _update_bb_bz and _approx_bezier.
  * @see lib/common/geom.c:ptToLine2
  */
-function ptToLine2(a: Point, b: Point, p: Point): number {
+export function ptToLine2(a: Point, b: Point, p: Point): number {
   const dx = b.x - a.x;
   const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
+  let a2 = fma(p.y - a.y, dx, -(dy * (p.x - a.x)));
   a2 *= a2; // square — ensures positive
   if (a2 < SMALL) return 0; // avoid 0/0 problems
-  return a2 / (dx * dx + dy * dy);
+  return a2 / fma(dx, dx, dy * dy);
 }
 
 /**

package/src/common/splines-routespl.ts

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

package/src/common/textmeasure-lookup.ts

@@ -8,6 +8,8 @@ import {
   ALL_FONT_METRICS,
   type FontFamilyData,
 } from "./textmeasure-lut-data.js";
+import { registerRenderState } from "./render-state.js";
+import { agwarningf } from './agerr.js';
 
 /** Times is always present; used as the fallback family. */
 export const TIMES_FALLBACK: FontFamilyData = ALL_FONT_METRICS[0]!;
@@ -30,8 +32,13 @@ export function normalizeFontName(name: string): string {
   return result;
 }
 
-/** Set of font names that have already triggered the fallback warning. */
+/**
+ * Font names that have already triggered the fallback warning: C's emit_once
+ * set, emptied per render (a native run is one process; emit_once_reset).
+ * @see lib/common/emit.c:emit_once
+ */
 const warnedFontNames = new Set<string>();
+registerRenderState(() => warnedFontNames.clear());
 
 /** @see lib/common/textspan_lut.c:get_metrics_for_font_family */
 export function getFamilyMetrics(fontName: string): FontFamilyData {
@@ -41,8 +48,8 @@ export function getFamilyMetrics(fontName: string): FontFamilyData {
   }
   if (!warnedFontNames.has(fontName)) {
     warnedFontNames.add(fontName);
-    console.warn(
-      `Warning: no hard-coded metrics for '${fontName}'.  ` +
+    agwarningf(
+      `no hard-coded metrics for '${fontName}'.  ` +
         `Falling back to 'Times' metrics`,
     );
   }

package/src/common/textmeasure.ts

@@ -10,6 +10,8 @@
 import { type FontFamilyData } from "./textmeasure-lut-data.js";
 import { getFamilyMetrics, normalizeFontName } from "./textmeasure-lookup.js";
 import { canvasFont } from "./css-font.js";
+import { agwarningf } from "./agerr.js";
+import { registerRenderState } from "./render-state.js";
 
 /** Number of hard-coded font families in the LUT. */
 export const LUT_FAMILY_COUNT = 11;
@@ -72,12 +74,53 @@ function getVariantWidths(
 // ── Character width lookup ────────────────────────────────────────────────────
 
 const SPACE_CHAR_CODE = 32;
+const FIRST_NON_ASCII = 128;
+
+/**
+ * C's two `static bool warning_already_reported` flags, one per warning.
+ * Once per render (AD-4), as one native process renders one graph.
+ * @see lib/common/textspan_lut.c:estimate_character_width_canonical
+ */
+const warned = new Set<string>();
+const NON_ASCII_FLAG = "non-ascii";
+const ASCII_FLAG = "ascii";
+
+registerRenderState(() => warned.clear());
+
+/**
+ * The C format strings already begin with `Warning: `, and agwarningf adds its
+ * own prefix, so native prints `Warning: Warning: ...`. The trailing newline
+ * of the C format is the line terminator `console.warn` supplies.
+ */
+function warnNonAscii(character: number): void {
+  if (warned.has(NON_ASCII_FLAG)) return;
+  warned.add(NON_ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of non-ASCII character ${character}. Falling back to width of space character`,
+  );
+}
+
+function warnAscii(character: number): void {
+  if (warned.has(ASCII_FLAG)) return;
+  warned.add(ASCII_FLAG);
+  agwarningf(
+    `Warning: no value for width of ASCII character ${character}. Falling back to 0`,
+  );
+}
 
 /** @see lib/common/textspan_lut.c:estimate_character_width_canonical */
 function charWidthUnits(widths: readonly number[], charCode: number): number {
-  const code = charCode >= 128 ? SPACE_CHAR_CODE : charCode;
+  let code = charCode;
+  if (code >= FIRST_NON_ASCII) {
+    warnNonAscii(code);
+    code = SPACE_CHAR_CODE;
+  }
   const w = widths[code] ?? -1;
-  return w < 0 ? 0 : w;
+  if (w < 0) {
+    warnAscii(code);
+    return 0;
+  }
+  return w;
 }
 
 /**

package/src/gvc/anchor.ts

@@ -21,6 +21,7 @@ import { substObjAnchor, preprocessTooltip } from '../common/subst.js';
 import { parseStyleFlags } from '../common/style-resolve.js';
 import { nodeAttr } from '../common/poly-init.js';
 import { bezier } from '../common/bezier.js';
+import { ptToLine2 } from '../common/splines-geom.js';
 import type { RendererPlugin } from './context.js';
 import { MapShape, type ObjState, type RenderJob } from './job.js';
 
@@ -231,8 +232,6 @@ export function beginAnchorIf(renderer: RendererPlugin, job: RenderJob): boolean
 const DFLT_SAMPLE = 20;
 /** HW: maximum distance from line, in points. @see lib/common/emit.c:739 */
 const MAP_HW = 2.0;
-/** SMALL: 0/0 guard in ptToLine2. @see lib/common/geom.c:176 */
-const MAP_SMALL = 0.0000000001;
 
 /**
  * Coordinate-transform context for the imagemap device. `bb` is the unpadded
@@ -430,16 +429,6 @@ export function computeLabelRectMap(lab: TextlabelT, obj: ObjState, ctx: MapCtx)
 
 // --- Edge spline hot spots (map_output_bspline) --------------------------
 
-/** ptToLine2: squared distance from p to segment (a,b). @see lib/common/geom.c */
-function ptToLine2(a: Point, b: Point, p: Point): number {
-  const dx = b.x - a.x;
-  const dy = b.y - a.y;
-  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
-  a2 *= a2;
-  if (a2 < MAP_SMALL) return 0;
-  return a2 / (dx * dx + dy * dy);
-}
-
 /** check_control_points: both handles within HW of the chord. @see emit.c */
 function checkControlPoints(cp: Point[]): boolean {
   return ptToLine2(cp[0]!, cp[3]!, cp[1]!) < MAP_HW * MAP_HW

package/src/gvc/device-cluster.ts

@@ -13,7 +13,8 @@ import {
   parseStyleFlags, resolvePenColor, resolvePenType, resolvePenWidth,
   resolveClusterFillEx,
 } from '../common/style-resolve.js';
-import { resolveRenderColor, withColorScheme } from '../render/color-resolve.js';
+import { resolveRenderColor, withColorScheme, reportColorNames } from '../render/color-resolve.js';
+import { parseSegs } from '../common/multicolor.js';
 
 /**
  * Copy gradient fields from a linear/radial ResolvedFill onto obj.
@@ -101,14 +102,41 @@ export function applyClusterObjState(sg: Graph, job: RenderJob): boolean {
   const obj = job.obj;
   // C wraps the cluster color block with setColorScheme. @see emit.c:3800/3943
   return withColorScheme(clusterAttr(sg, 'colorscheme'), () => {
+    // C resolves the fill (set_fillcolor / gradient vals) before the pen,
+    // which is set just before gvrender_box. @see emit.c:3846-3868 vs 3907-3913
+    const filled = applyClusterFill(obj, fillRes);
     applyClusterPenState(obj, sg);
-    if (fillRes.kind === 'none') { obj.fill = FillType.None; return false; }
-    if (fillRes.kind === 'solid') {
-      obj.fill = FillType.Solid;
-      obj.fillColor = resolveRenderColor(fillRes.color);
-      return true;
-    }
-    applyClusterGradient(obj, fillRes);
-    return true;
+    reportColorNames(stripedClusterColors(sg));
+    return filled;
   });
 }
+
+/**
+ * The colours stripedBox sets for a `style=striped` cluster (not rounded): each
+ * segment of the fill spec with a positive width, after the pen.
+ * @see lib/common/emit.c:3896-3906 emit_clusters (striped branch)
+ * @see lib/common/emit.c:595 stripedBox
+ */
+function stripedClusterColors(sg: Graph): string[] {
+  const flags = parseStyleFlags(clusterStyle(sg));
+  if (!flags.striped || flags.rounded) return [];
+  const color = clusterAttr(sg, 'color') ?? '';
+  let fill = clusterAttr(sg, 'fillcolor') || color;
+  const bg = clusterAttr(sg, 'bgcolor') ?? '';
+  if ((!flags.filled || fill === '') && bg !== '') fill = bg;
+  const { segs, error } = parseSegs(fill === '' ? 'lightgrey' : fill);
+  if (error === 1 || error === 2) return [];
+  return segs.flatMap((seg) => (seg.color !== null && seg.t > 0 ? [seg.color] : []));
+}
+
+/** The fill half of {@link applyClusterObjState}; true when the box is filled. */
+function applyClusterFill(obj: ObjState, fillRes: ResolvedFill): boolean {
+  if (fillRes.kind === 'none') { obj.fill = FillType.None; return false; }
+  if (fillRes.kind === 'solid') {
+    obj.fill = FillType.Solid;
+    obj.fillColor = resolveRenderColor(fillRes.color);
+    return true;
+  }
+  applyClusterGradient(obj, fillRes);
+  return true;
+}

package/src/gvc/device-labels.ts

@@ -10,6 +10,7 @@
 
 import type { Graph } from '../model/graph.js';
 import type { Node } from '../model/node.js';
+import type { Edge } from '../model/edge.js';
 import type { RendererPlugin } from './context.js';
 import type { RenderJob } from './job.js';
 import type { TextlabelT } from '../common/types.js';
@@ -17,6 +18,8 @@ import type { TextSpan } from '../common/emit-types.js';
 import type { PlacedHtml } from '../common/htmltable-pos.js';
 import { gvrenderTextspan, withLabelEmitState } from './textspan-emit.js';
 import { emitHtmlLabel } from '../common/htmltable-emit.js';
+import { reportColorNames } from '../render/color-resolve.js';
+import { htmlLabelColors } from '../common/htmltable-emit-fill.js';
 
 /** valign codes stored on textlabel_t. @see lib/common/types.h:textlabel_t.valign */
 const VALIGN_TOP = 't'.charCodeAt(0);
@@ -38,6 +41,29 @@ function labelSpanX(lp: TextlabelT, just: 'l' | 'n' | 'r'): number {
   return lp.pos.x;
 }
 
+/**
+ * The names emit_label hands to gvrender_resolve_color: an HTML label's walk,
+ * or a plain label's fontcolor (set once, before the spans, when there is a
+ * span).
+ * @see lib/common/labels.c:emit_label
+ */
+export function labelColorNames(lp: TextlabelT): string[] {
+  if (lp.html) return lp.u.kind === 'html' ? htmlLabelColors(lp.u.html as PlacedHtml) : [];
+  return lp.u.kind === 'txt' && lp.u.nspans >= 1 ? [lp.fontcolor] : [];
+}
+
+/**
+ * Report the unknown colours of an edge's four labels in emit_end_edge order
+ * (label, xlabel, head, tail), each only when placed.
+ * @see lib/common/emit.c:emit_edge_label
+ */
+export function reportEdgeLabelColors(e: Edge): void {
+  const labels = [e.info.label, e.info.xlabel, e.info.head_label, e.info.tail_label];
+  for (const lp of labels as Array<TextlabelT | undefined>) {
+    if (lp?.set) reportColorNames(labelColorNames(lp));
+  }
+}
+
 /**
  * Emit one label's text spans if present and placed.
  * Shared by edge-label, node-xlabel, and graph-label slots.
@@ -59,6 +85,7 @@ export function renderOneLabel(
   // default pos. Callers mirroring the existence-only sites pass false.
   if (!lp) return;
   if (requireSet && !lp.set) return;
+  reportColorNames(labelColorNames(lp));
   // HTML branch: @see lib/common/labels.c:emit_label (226-230)
   // C routes to emit_html_label(job, lp->u.html, lp) using lp->pos as anchor.
   if (lp.html) {