@knowvah/dot-engine 2.7.0 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "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/agerr.ts

@@ -4,6 +4,15 @@
  * 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.
+ *
+ * Partial lines (AD-7): the port strips C's trailing `\n` at every call site,
+ * so `agerr`/`agerrorf`/`agwarningf` always finish a line. A site whose C
+ * message has no trailing `\n` (`emit.c:parseSegs`) opts in with
+ * {@link agerrPartial}: the text is held, and the next `agerr*` message is
+ * appended to it (its own prefix included, as C's `out` writes it) and the
+ * joined line printed on the held line's channel. A held line is flushed on
+ * its own by {@link agerrLineOn}/{@link agerrFinished} and by render-state
+ * reset.
  */
 
 import { registerRenderState } from './render-state.js';
@@ -30,7 +39,14 @@ const OCTAL_RADIX = 8;
  */
 let lastLevel: 'error' | 'warning' = 'warning';
 
+/**
+ * The held partial line and its channel (one slot: stderr has one cursor).
+ * Cleared by {@link flushPending}; reset per render.
+ */
+const pending: { line: string | null; channel: AgerrChannel } = { line: null, channel: 'warn' };
+
 registerRenderState(() => {
+  flushPending();
   lastLevel = 'warning';
 });
 
@@ -55,25 +71,70 @@ export function escapeControl(message: string): string {
  * channel, escaped as `default_usererrf` would.
  */
 export function agerrLineOn(channel: AgerrChannel, line: string): void {
+  flushPending();
+  writeLine(channel, line);
+}
+
+/** Print a held partial line, if any, as its own line. */
+function flushPending(): void {
+  if (pending.line === null) return;
+  const { line, channel } = pending;
+  pending.line = null;
+  writeLine(channel, line);
+}
+
+function writeLine(channel: AgerrChannel, line: string): void {
   if (channel === 'warn') console.warn(escapeControl(line));
   else console.error(escapeControl(line));
 }
 
+/** The text `out` writes for one message: prefix (none for AGPREV) + body. */
+function assemble(level: AgerrLevel, msg: string): string {
+  if (level === 'prev') return msg;
+  const prefix = level === 'error' ? PREFIX_ERROR : PREFIX_WARNING;
+  return `${prefix}${PREFIX_SEP}${msg}`;
+}
+
+/** Console channel of a message; AGPREV continues the previous level's. */
+function channelOf(level: AgerrLevel): AgerrChannel {
+  const eff = level === 'prev' ? lastLevel : level;
+  return eff === 'warning' ? 'warn' : 'error';
+}
+
+/**
+ * Shared body of `agerr`/`agerrPartial`: record the level, assemble the text,
+ * join it onto a held line (which fixes the channel), then hold or print.
+ */
+function emit(level: AgerrLevel, msg: string, channel: AgerrChannel | undefined, hold: boolean): void {
+  const target = channel ?? channelOf(level);
+  if (level !== 'prev') lastLevel = level;
+  const text = assemble(level, msg);
+  if (pending.line === null) {
+    pending.channel = target;
+    pending.line = text;
+  } else pending.line += text;
+  if (!hold) flushPending();
+}
+
 /**
  * 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).
+ * the previous level's channel). Finishes the line, joining a held partial.
  * @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}`);
+  emit(level, msg, channel, false);
+}
+
+/**
+ * `agerr` for a C message with no trailing `\n`: the line stays open and the
+ * next `agerr*` message continues it. The channel follows this (first)
+ * message's level unless `channel` is given.
+ * @see lib/cgraph/agerror.c:out
+ */
+export function agerrPartial(level: AgerrLevel, msg: string, channel?: AgerrChannel): void {
+  emit(level, msg, channel, true);
 }
 
 /** @see lib/cgraph/agerror.c:agerrorf */

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/fma.ts

@@ -13,6 +13,10 @@
  * half-ULP boundary of s — not observed for any supported input
  * (validated against a full-precision C oracle).
  *
+ * A non-finite product or addend short-circuits to `a * b + c` (or the
+ * non-finite `c` when a and b are finite) before the split: the split's `a·b - p` terms turn an
+ * infinite operand into Inf - Inf = NaN where hardware fmadd gives ±Inf.
+ *
  * Per Boldo & Muller, "Some functions computable with a fused-mac"
  * (IEEE Trans. Computers, 2011) — the exact emulation needs
  * round-to-odd; this is the standard approximation without it.
@@ -25,8 +29,14 @@ const SPLIT = 134217729;
  * round(a·b + c) with one rounding (fmadd).
  */
 export function fma(a: number, b: number, c: number): number {
-  /* Dekker two-product: p + err == a·b exactly */
   const p = a * b;
+  /* Non-finite product or addend: the IEEE fmadd result is p + c, except
+   * that a finite a·b which merely overflowed p yields the non-finite c. */
+  if (!Number.isFinite(p) || !Number.isFinite(c)) {
+    return Number.isFinite(a) && Number.isFinite(b) && !Number.isFinite(c) ? c : p + c;
+  }
+
+  /* Dekker two-product: p + err == a·b exactly */
   const at = SPLIT * a;
   const ahi = at - (at - a);
   const alo = a - ahi;

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

@@ -16,7 +16,7 @@ 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 { firstColor, resolveRenderColor } from '../render/color-resolve.js';
+import { firstColor, resolveFillColorName, 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';
@@ -28,7 +28,7 @@ import {
   BORDER_BOTTOM,
   BORDER_MASK,
 } from './htmltable-types.js';
-import { parseSegs, parseSegsSilent } from './multicolor.js';
+import { MSG_MANY_COLORS, parseSegs, parseSegsSilent } from './multicolor.js';
 import { agwarningf } from './agerr.js';
 import { registerRenderState } from './render-state.js';
 
@@ -43,9 +43,6 @@ export interface HtmlStopColor {
   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
@@ -197,8 +194,10 @@ function penTypeOf(style: string | undefined): PenType {
  * @see lib/common/htmltable.c:setFill
  */
 export function withHtmlPaint(paint: HtmlPaint, job: RenderJob, drawFn: () => void): void {
+  // gvrender_set_fillcolor hands the cut name to colorxlate even when empty
+  // (":red" -> ""), so the empty name warns and fills opaque black.
   paintObj.fillColor = paint.fill !== undefined
-    ? resolveRenderColor(firstColor(paint.fill)) : { type: 'none' };
+    ? resolveFillColorName(firstColor(paint.fill)) : { type: 'none' };
   paintObj.penColor = paint.pen !== undefined
     ? resolveRenderColor(paint.pen) : { type: 'string', s: 'transparent' };
   applyHtmlFill(paint);
@@ -425,7 +424,12 @@ 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]];
+  if (spec !== null) return [spec[0], spec[1]];
+  // A spec parseSegs rejects, or an empty cut name (":red"), is resolved by
+  // setFill itself, after findStopColor's own diagnostics: leave it to the
+  // paint. @see lib/common/htmltable.c:setFill
+  if (parseSegsSilent(bgcolor).error !== 0 || firstColor(bgcolor) === '') return [];
+  return [bgcolor];
 }
 
 /** One cell in emit_html_cell order: fill, border, then the child. */

package/src/common/htmltable-label.ts

@@ -11,6 +11,7 @@
 
 import type { TextlabelT } from './types.js';
 import type { TextMeasurer } from './textmeasure.js';
+import type { ImageResolver } from '../gvc/image-resolver.js';
 import type { HtmlLabel, ImageSizer } from './htmltable-types.js';
 import { sizeHtmlLabel, parseHtmlLabelRv, inheritTablePenColor } from './htmltable.js';
 import { makeLabel } from './make-label.js';
@@ -28,7 +29,9 @@ export interface HtmlLabelResult {
 }
 
 /** The label's font, the object's pen color, and the `<IMG>` sizer. */
-export type HtmlLabelInfo = HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string };
+export type HtmlLabelInfo = HtmlFontInfo & {
+  imageSizer?: ImageSizer; imageResolver?: ImageResolver; imageDpi?: number; pencolor?: string;
+};
 
 /**
  * make_html_label: parse, size and position an HTML-like label. Returns C's
@@ -44,7 +47,7 @@ export function makeHtmlLabelTo(
   measurer: TextMeasurer,
   stderr: StderrLines,
 ): HtmlLabelResult {
-  const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
+  const { fontname, fontsize, fontcolor, imageSizer, imageResolver, imageDpi, pencolor } = finfo;
   let lbl: HtmlLabel, lexWarn: boolean; // lexWarn: htmllex.c's ctx->warn, rv bit 1
   try {
     ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content, stderr));
@@ -61,7 +64,7 @@ export function makeHtmlLabelTo(
   // @see lib/common/htmltable.c:1911 (getPenColor), :1406/:1556 (inheritance)
   if (lbl.kind === 'table') inheritTablePenColor(lbl.table, pencolor);
   const rv = Number(lexWarn) | sizeHtmlLabel(lbl, measurer, {
-    fontsize, fontname, imageSizer, stderr,
+    fontsize, fontname, imageSizer, imageResolver, imageDpi, stderr,
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
   const dim = lbl.dimen ?? { w: 0, h: 0 };

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

@@ -33,6 +33,22 @@ const DEC_DIGIT = /[0-9]/;
 const HEX_DIGIT = /[0-9A-Fa-f]/;
 /** Bytes expat's tokenizer rejects anywhere (BT_NONXML): controls other than tab, LF and CR. */
 const NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f]/;
+/** The same classification for U+FFFE, U+FFFF and a lone surrogate (the UTF-8 form of one is invalid). */
+const NON_XML_BEYOND_ASCII = /[\ufffe\uffff]/;
+const HIGH_SURROGATE = /[\ud800-\udbff]/;
+const LOW_SURROGATE = /[\udc00-\udfff]/;
+
+/**
+ * Whether the character at `k` is BT_NONXML in a value: what `CONTENT_NON_XML`
+ * (htmltable-lex-expat.ts) rejects in content, one tokenizer table for both.
+ * @see expat lib/asciitab.h
+ */
+function isNonXmlAt(text: string, k: number): boolean {
+  const c = text[k]!;
+  if (NON_XML.test(c) || NON_XML_BEYOND_ASCII.test(c)) return true;
+  if (HIGH_SURROGATE.test(c)) return !LOW_SURROGATE.test(text[k + 1] ?? '');
+  return LOW_SURROGATE.test(c) && !HIGH_SURROGATE.test(text[k - 1] ?? '');
+}
 
 /** A reference's digits from `i` up to `;`: the index after it, or where scanning stops. */
 function scanDigits(text: string, i: number, digit: RegExp): number | AttValueScan {
@@ -74,7 +90,7 @@ export function scanAttValue(text: string, j: number): AttValueScan {
     const c = text[k];
     if (c === undefined) return { partial: true };
     if (c === q) return { close: k };
-    if (c === '<' || NON_XML.test(c)) return { invalid: k };
+    if (c === '<' || isNonXmlAt(text, k)) return { invalid: k };
     if (c !== '&') {
       k++;
       continue;

package/src/common/htmltable.ts

@@ -22,9 +22,10 @@ import type {
   HtmlCell, HtmlCellContent, HtmlImage, HtmlLabel, HtmlTable, HtmlText,
   ImageSizer,
 } from './htmltable-types.js';
-import { findImageSize, imageIsSupplied, imageOpenWarning } from '../gvc/usershape.js';
+import { DEFAULT_DPI, imageIsSupplied, imageOpenWarning, usershapeSizePts } from '../gvc/usershape.js';
 import { registerRenderState } from './render-state.js';
 import { PointSet } from './pointset.js';
+import type { ImageResolver } from '../gvc/image-resolver.js';
 import type { TextMeasurer } from './textmeasure.js';
 import { buildLineRuns, runsAreSimple } from './htmltable-pos-runs.js';
 import { withTableFont } from './htmltable-fontinfo.js';
@@ -87,6 +88,10 @@ export interface HtmlSizeEnv {
   fontsize: number;
   fontname: string;
   imageSizer?: ImageSizer;
+  /** Per-context resolver: bytes it supplies count as a found file. */
+  imageResolver?: ImageResolver;
+  /** The graph's usershape dpi (`gvusershape_size` pixel to point); default 96. */
+  imageDpi?: number;
   stderr?: StderrLines; // the label's stderr; none: straight to the console
 }
 
@@ -132,20 +137,20 @@ const sizeTextContent = (
 /** Images whose sizing failed: size_html_img's rv = 1 on every later call. */
 const missingImages = { set: new WeakSet<HtmlImage>() };
 
-const sizeHtmlImg = (img: HtmlImage, { imageSizer, stderr }: HtmlSizeEnv): number => {
+const sizeHtmlImg = (img: HtmlImage, { imageSizer, imageResolver, imageDpi, 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.set.has(img) ? 1 : 0;
-  const sz = imageSizer !== undefined ? imageSizer(img.src) : findImageSize(img.src);
+  const sz = usershapeSizePts(img.src, imageDpi ?? DEFAULT_DPI, imageSizer);
   if (sz !== null) {
-    img.width = sz.w; img.height = sz.h;
+    img.width = sz.x; img.height = sz.y;
     return 0;
   }
   // 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)}`);
+  if (!imageIsSupplied(img.src, imageSizer, imageResolver)) 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}"`);

package/src/common/layers.ts

@@ -6,6 +6,7 @@
 // only in the layers it belongs to (its `layer` attribute, or all layers when
 // it has none). All of this is inert unless numLayers > 1.
 
+import { agwarningf } from './agerr.js';
 import type { Graph } from '../model/graph.js';
 import type { Node } from '../model/node.js';
 import type { Edge } from '../model/edge.js';
@@ -21,6 +22,11 @@ export interface LayerInfo {
   numLayers: number;
   sep: string;
   listSep: string;
+  /**
+   * C `gvc->layerlist`: `[count, l1, …, lcount, numLayers + 1]` from the
+   * `layerselect` attribute, or null when absent or matching no layer.
+   */
+  layerList: number[] | null;
 }
 
 /** Split `s` on any character in the `delims` set, dropping empty tokens
@@ -39,10 +45,13 @@ export function parseLayers(g: Graph): LayerInfo {
   // Conflict: a char in both sep sets → ignore listSep (C warns + clears it).
   if ([...sep].some((c) => listSep.includes(c))) listSep = '';
   if (p === undefined || p === '') {
-    return { layerIDs: [], numLayers: 1, sep, listSep };
+    return { layerIDs: [], numLayers: 1, sep, listSep, layerList: null };
   }
   const toks = splitOnSet(p, sep);
-  return { layerIDs: [null, ...toks], numLayers: toks.length, sep, listSep };
+  const info: LayerInfo = { layerIDs: [null, ...toks], numLayers: toks.length, sep, listSep, layerList: null };
+  const sel = g.attrs.get('layerselect');
+  if (sel !== undefined && sel !== '') info.layerList = parseLayerselect(info, sel);
+  return info;
 }
 
 function isNaturalNumber(s: string): boolean {
@@ -111,3 +120,23 @@ export function edgeInLayer(info: LayerInfo, layerNum: number, e: Edge): boolean
     return pn === '' || selectedLayer(info, layerNum, pn);
   });
 }
+
+/**
+ * Walk each layer index and keep those `selectedLayer` matches against `p`.
+ * Returns `[n, l1..ln, numLayers + 1]`, or null (after a warning) when nothing
+ * matches. The warning's "specifed" is native's spelling.
+ * @see lib/common/emit.c:parse_layerselect
+ */
+export function parseLayerselect(info: LayerInfo, p: string): number[] | null {
+  const picked: number[] = [];
+  for (let i = 1; i <= info.numLayers; i++) {
+    if (selectedLayer(info, i, p)) picked.push(i);
+  }
+  if (picked.length === 0) {
+    agwarningf(
+      `The layerselect attribute "${p}" does not match any layer specifed by the layers attribute - ignored.`,
+    );
+    return null;
+  }
+  return [picked.length, ...picked, info.numLayers + 1];
+}

package/src/common/layout-state.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * The C global `State` ("last finished phase"). It is a per-process variable
+ * in C; the port resets it per render (AD-4) to its initial value.
+ *
+ * @see lib/common/globals.h:State
+ */
+
+import { registerRenderState } from './render-state.js';
+
+/** Phase values for `State`. @see lib/common/const.h:GVBEGIN, GVSPLINES */
+export const GVBEGIN = 0;
+export const GVSPLINES = 1;
+
+/**
+ * Holder for the C global `State`. C's initial value is 0 (BSS) and
+ * graph_init assigns GVBEGIN, which is the same value.
+ * @see lib/common/input.c:graph_init (State = GVBEGIN)
+ */
+const layoutState = { state: GVBEGIN };
+
+registerRenderState(() => {
+  layoutState.state = GVBEGIN;
+});
+
+/** Read `State`. @see lib/common/globals.h:State */
+export function getState(): number {
+  return layoutState.state;
+}
+
+/** Assign `State`. @see lib/common/globals.h:State */
+export function setState(value: number): void {
+  layoutState.state = value;
+}

package/src/common/make-label.ts

@@ -16,8 +16,11 @@ 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';
+import { usershapeDpi } from '../gvc/usershape.js';
 
 export const DEFAULT_FONTSIZE = 14.0;
 /** C's default fontname (non-Windows); renderers alias it, e.g. SVG
@@ -33,17 +36,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;
@@ -205,11 +218,14 @@ export function makeAnyLabel(
     // pen color so an HTML table/cell border with no explicit COLOR inherits
     // it (htmltable.c:1911 getPenColor). @see getPenColor
     // ADR-2: a per-context sizer (when set) wins over the global one.
-    const imageSizer = obj !== undefined ? rootOf(obj).info.gvc?.imageSizer : undefined;
+    const root = obj !== undefined ? rootOf(obj) : undefined;
+    const imageSizer = root?.info.gvc?.imageSizer;
+    const imageResolver = root?.info.gvc?.imageResolver;
+    const imageDpi = root !== undefined ? usershapeDpi(root.attrs) : undefined;
     // One stderr for the label: doInt's unterminated warning runs into the
     // next write, `in label of ...` included (agerr AGPREV).
     const stderr = labelStderr();
-    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer, stderr);
+    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer, imageResolver, imageDpi }, measurer, stderr);
     if (rv !== 0 && obj !== undefined) stderr.write(`${inLabelOf(obj)}\n`);
     stderr.flush();
     return label;

package/src/common/multicolor.ts

@@ -13,7 +13,7 @@
  * @see lib/common/emit.c:470 parseSegs
  */
 
-import { agerr, agerrorf, agwarningf } from './agerr.js';
+import { agerr, agerrPartial, agerrorf } from './agerr.js';
 import type { Edge } from '../model/edge.js';
 import { registerRenderState } from './render-state.js';
 
@@ -64,6 +64,9 @@ function claimWarned(): boolean {
 /** A claim that never fires: parses without touching or consuming the flag. */
 const claimNever = (): boolean => false;
 
+/** @see lib/common/emit.c:findStopColor */
+export const MSG_MANY_COLORS = 'More than 2 colors specified for a gradient - ignoring remaining';
+
 /** @see lib/common/emit.c:451 EPS */
 const EPS = 1e-5;
 
@@ -187,9 +190,10 @@ function scanSegs(
  * On rv 1 or 2 the returned segs array is empty.
  *
  * The rv 2 error and rv 3 warning are printed here, once per process (the
- * shared `warned` flag). C's callers then append an AGPREV line for rv > 1;
- * `context` supplies it (e.g. `in edge a -> b`): the warning continues the
- * same line as C's AGPREV does, the error's context follows on its own line.
+ * shared `warned` flag). The warning is a held partial line (no `\n`, as in
+ * C); C's callers then append an AGPREV line for rv > 1; `context` supplies it
+ * (e.g. `in edge a -> b`) and completes the held line. Without `context` the
+ * next agerr message continues the line.
  *
  * @see lib/common/emit.c:470 parseSegs
  */
@@ -199,8 +203,10 @@ export function parseSegs(
 ): { segs: ColorSeg[]; error: 0 | 1 | 2 | 3 } {
   const result = scanSegs(colorlist, claimWarned);
   if (result.error === 3) {
-    const tail = context === undefined ? '' : context();
-    agwarningf(`Total size > 1 in "${colorlist}" color spec ${tail}`);
+    // C's message has no newline: the line stays open for the next agerr*
+    // call (or the caller's AGPREV context line).
+    agerrPartial('warning', `Total size > 1 in "${colorlist}" color spec `);
+    if (context !== undefined) agerr('prev', context());
   } else if (result.error === 2) {
     agerrorf(`Illegal value in "${colorlist}" color attribute; float expected after ';'`);
     if (context !== undefined) agerr('prev', context());

package/src/common/nodeinit.ts

@@ -15,7 +15,7 @@ import type { TextMeasurer } from './textmeasure.js';
 import type { PolygonT, ShapeDesc, TextlabelT } from './types.js';
 import { ShapeKind } from './types.js';
 import { bindShape } from './shapes.js';
-import { assignShapeInfo, buildNodeLabel, nodeAttr, readFontAttrs } from './poly-init.js';
+import { assignShapeInfo, buildNodeLabel, nodeAttr, nodeImageSize, readFontAttrs } from './poly-init.js';
 import { makeAnyLabel } from './make-label.js';
 import { isHtmlValue, htmlValueContent } from './html-string.js';
 import { NODE_XLABEL } from '../layout/dot/rank.js';
@@ -154,6 +154,7 @@ export function polySizeParamsFromNode(
     isPlain: shape.name === 'plain',
     optionShape: poly.option.shape, // size_gen discriminant (STAR/CYLINDER)
     nojustify: mapbool(nodeAttr(n, g, 'nojustify')), // shapes.c:2133
+    imageSize: nodeImageSize(n, g), // shapes.c:2039-2051
     flip,
   };
 }

package/src/common/poly-init.ts

@@ -10,6 +10,7 @@
 import type { Node } from '../model/node.js';
 import type { Graph } from '../model/graph.js';
 import type { TextMeasurer } from './textmeasure.js';
+import { nodeAttr } from './attr-get.js';
 import type { PolygonT, ShapeDesc } from './types.js';
 import { ShapeKind } from './types.js';
 import type { TextlabelT } from './types.js';
@@ -25,31 +26,16 @@ import {
 } from './make-label.js';
 import { computeVertices } from './poly-vertices.js';
 import { agwarningf } from './agerr.js';
-import { imageIsSupplied, imageOpenWarning } from '../gvc/usershape.js';
+import { imageIsSupplied, imageOpenWarning, usershapeDpi, usershapeSizePts } from '../gvc/usershape.js';
 
 // Default half-dimensions in points (72 dpi, 0.75 in wide, 0.5 in tall)
 const DEFAULT_LW = 27;
 const DEFAULT_RW = 27;
 const DEFAULT_HT = 36;
 
-/**
- * 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);
-}
+// nodeAttr moved to attr-get.ts (leaf module, shared with make-label.ts);
+// re-exported so existing importers are unchanged.
+export { nodeAttr };
 
 /** Read label-font attributes from node, falling back to defaults. */
 export function readFontAttrs(n: Node, g: Graph): {
@@ -128,6 +114,23 @@ function warnMissingImage(n: Node, g: Graph, shapefile: string | undefined): voi
   agwarningf(`No or improper image="${image}" for node "${n.name}"`);
 }
 
+/**
+ * poly_init's imagesize for a non-custom shape's `image=`: gvusershape_size in
+ * points plus the fixed 2pt padding, and GD_has_images. Null (C's imagesize 0)
+ * when there is no image or the caller supplies no size; the missing-image
+ * warning stays in warnMissingImage.
+ * @see lib/common/shapes.c:2039-2051
+ */
+export function nodeImageSize(n: Node, g: Graph): { x: number; y: number } | undefined {
+  const shapefile = nodeAttr(n, g, 'shapefile');
+  if (shapefile !== undefined && shapefile !== '') return undefined;
+  const gvc = g.root.info.gvc;
+  const sz = usershapeSizePts(nodeAttr(n, g, 'image'), usershapeDpi(g.root.attrs), gvc?.imageSizer);
+  if (sz === null) return undefined;
+  g.root.info.has_images = true;
+  return { x: sz.x + 2, y: sz.y + 2 }; // some fixed padding
+}
+
 export function polyInit(n: Node, g: Graph, measurer: TextMeasurer): void {
   const shapeName = nodeAttr(n, g, 'shape') ?? 'ellipse';
   const shapefile = nodeAttr(n, g, 'shapefile');