@knowvah/dot-engine 2.7.1 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.7.1",
+  "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/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

@@ -20,6 +20,7 @@ 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
@@ -217,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

@@ -26,7 +26,7 @@ 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;
@@ -114,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');

package/src/common/poly-sizing.ts

@@ -89,6 +89,7 @@ export interface PolySizeParams {
    * @see lib/common/shapes.c:2132-2145
    */
   nojustify?: boolean;
+  imageSize?: Point; // padded image size in points, shapes.c:2020-2051 imagesize
 }
 
 /** Node geometry in points: left/right half-widths and height. */
@@ -550,7 +551,8 @@ export function polySize(p: PolySizeParams): PolySizeResult {
   const init = initialSizePts(p);
   const dimen = quantize(padLabelDimen(p.labelDimen, p.margin, p.isPlain), p.quantumIn);
   const { sides, isBox } = effectiveShape(p);
-  let bb: Point = { x: dimen.x, y: dimen.y };
+  const img = p.imageSize ?? { x: 0, y: 0 }; // shapes.c:2055: bb = max(dimen, imagesize)
+  let bb: Point = { x: Math.max(dimen.x, img.x), y: Math.max(dimen.y, img.y) };
   // C shapes.c:2073-2085 dispatch: box → exact fit; poly_desc shapes (star,
   // cylinder) → their size_gen; everything else → generic ellipse fit.
   if (isBox) {
@@ -583,8 +585,6 @@ export function polySize(p: PolySizeParams): PolySizeResult {
  * Compute the label's justification borders (ND_label->space) and vertical
  * alignment — the "space available for label" block of poly_init. `bb` is the
  * final (constrained) box; `minBb` is the pre-constraint shape-fit box.
- * Image sizing is unported, so `imagesize` is 0 (which matches C for the
- * missing-image repro cases); revisit when image loading lands.
  * @see lib/common/shapes.c:poly_init (2132-2152)
  */
 function labelSpace(
@@ -604,7 +604,7 @@ function labelSpace(
     spaceX = dimen.x - spacex;
   }
   // space.y: !fixedshape → dimen.y + (bb.y - min_bb.y); fixedshape keeps dimen.y.
-  const spaceY = fixedshape ? dimen.y : dimen.y + (bb.y - minBb.y);
+  const spaceY = fixedshape ? dimen.y : dimen.y + ((bb.y - minBb.y) + Math.max(0, (p.imageSize?.y ?? 0) - dimen.y));
   return { space: { x: spaceX, y: spaceY }, valign: labelValign(p) };
 }
 

package/src/common/postproc.ts

@@ -27,6 +27,7 @@ import {
 } from '../layout/dot/init.js';
 import { addXLabels } from './xlabels-place.js';
 import { registerRenderState } from './render-state.js';
+import { getState, GVSPLINES } from './layout-state.js';
 import { agerrorf } from './agerr.js';
 
 /** Concentrated multi-edge duplicate — never drawn. @see lib/common/const.h:IGNORED */
@@ -221,7 +222,9 @@ function translateDrawing(g: Graph): void {
 
   for (const v of g.nodes.values()) {
     mapNode(v);
-    // State == GVSPLINES is always true post-spline-routing in the dot pipeline
+    // C: `if (State == GVSPLINES)` guards the whole edge loop; layouts that
+    // never route (patchwork, osage) leave State at GVBEGIN.
+    if (getState() !== GVSPLINES) continue;
     for (const e of g.edges) {
       if (e.tail !== v) continue;
       // C map_edge: a spline-less (non-concentrate, non-IGNORED) edge was