@knowvah/dot-engine 2.6.6 → 2.6.8

package/src/common/htmltable-parse.ts

@@ -44,12 +44,11 @@ const MSG_TEXT_BEFORE_TABLE = 'Syntax error: non-space string used before <TABLE
 /** @see lib/common/htmlparse.y:298 (table rule) */
 const MSG_TEXT_AFTER_TABLE = 'Syntax error: non-space string used after </TABLE>';
 
-/**
- * C's `nonSpace` on the lexer's text, which has already dropped control
- * characters; the port's tokens still carry tab, LF and CR.
- * @see lib/common/htmlparse.y:nonSpace
- */
-const nonSpace = (text: string): boolean => /[^ \t\n\r]/.test(text);
+/** Any character other than a space (the lexer already dropped control characters). @see lib/common/htmlparse.y:nonSpace */
+const nonSpace = (text: string): boolean => /[^ ]/.test(text);
+
+/** Text in `ctx->xb` that no token carried, which the table rule's nonSpace also reads. */
+const heldNonSpace = (tbl: Token | undefined): boolean => tbl?.type === 'open' && nonSpace(tbl.heldText ?? '');
 
 /**
  * The parse failure C reports through `htmlerror` when the lexer last returned
@@ -93,42 +92,40 @@ const applyBrTag = (
   consumeClose(s, 'BR');
 };
 
-const applyFontTag = (
-  s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
-): void => {
-  consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, {
-    fontColor: t.attrs['color'],
-    fontFace: t.attrs['face'],
-    fontSize: num(t.attrs['point-size']),
-  }));
+/**
+ * `font text n_font` and the other font-style rules: `text` is one or more
+ * text items, and the matching close tag must follow it. Anything else, an
+ * empty element included, is a syntax error at the token found instead.
+ * @see lib/common/htmlparse.y:textitem
+ */
+const parseStyledText = (s: ParseState, tag: string, fontStack: FontState[], items: HtmlTextItem[]): void => {
   const inner = parseText(s, fontStack);
   fontStack.pop();
-  items.push(...inner.items);
   const nxt = peek(s);
-  if (nxt?.type === 'close' && nxt.tag === 'FONT') consume(s);
+  if (inner.items.length === 0 || nxt?.type !== 'close' || nxt.tag !== tag) {
+    throw parseError(s, nxt, MSG_SYNTAX_ERROR);
+  }
+  items.push(...inner.items);
+  consume(s);
 };
 
-const applyInlineTag = (
+/** `font text n_font` / `bold text n_bold` / ...: push the tag's font, parse its text, pop. */
+const applyStyleTag = (
   s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
 ): void => {
   consume(s);
-  const font = fontStack[fontStack.length - 1] ?? {};
-  fontStack.push(mergeFontState(font, inlineFontState(t.tag, t.attrs)));
-  const inner = parseText(s, fontStack);
-  fontStack.pop();
-  items.push(...inner.items);
-  const nxt = peek(s);
-  if (nxt?.type === 'close' && nxt.tag === t.tag) consume(s);
+  const own = t.tag === 'FONT'
+    ? { fontColor: t.attrs['color'], fontFace: t.attrs['face'], fontSize: num(t.attrs['point-size']) }
+    : inlineFontState(t.tag, t.attrs);
+  fontStack.push(mergeFontState(fontStack[fontStack.length - 1] ?? {}, own));
+  parseStyledText(s, t.tag, fontStack, items);
 };
 
 const applyOpenTag = (
   s: ParseState, t: OpenToken, fontStack: FontState[], items: HtmlTextItem[],
 ): boolean => {
   if (t.tag === 'BR') { applyBrTag(s, t, fontStack, items); return true; }
-  if (t.tag === 'FONT') { applyFontTag(s, t, fontStack, items); return true; }
-  if (isInlineTag(t.tag)) { applyInlineTag(s, t, fontStack, items); return true; }
+  if (t.tag === 'FONT' || isInlineTag(t.tag)) { applyStyleTag(s, t, fontStack, items); return true; }
   return false;
 };
 
@@ -194,7 +191,7 @@ const parseFontTable = (s: ParseState, open: OpenToken, fontStack: FontState[]):
   fontStack.push(wrapperFont(open, fontStack));
   const textBefore = skipStrings(s);
   const tblTok = peek(s);
-  if (textBefore && tblTok !== undefined) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
+  if ((textBefore || heldNonSpace(tblTok)) && tblTok !== undefined) throw parseError(s, tblTok, MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   const textAfter = skipStrings(s);
   const close = peek(s);
@@ -222,13 +219,11 @@ const rejectTableAfterTag = (s: ParseState, start: number): void => {
 // Cell content helpers — mirrors htmlparse.y cell rule
 // ---------------------------------------------------------------------------
 
-const parseImgContent = (
-  s: ParseState, t: OpenToken, cellAttrs: Record<string, string>,
-): HtmlImage => {
+const parseImgContent = (s: ParseState, t: OpenToken): HtmlImage => {
   consume(s);
   const img: HtmlImage = {
     kind: 'image',
-    src: cellAttrs['src'] ?? t.attrs['src'] ?? '',
+    src: t.attrs['src'] ?? '',
     scale: t.attrs['scale'],
   };
   consumeClose(s, 'IMG');
@@ -249,7 +244,7 @@ const scanCellTable = (
   s: ParseState, t: Token, fontStack: FontState[], st: CellScan,
 ): HtmlCellContent[] => {
   if (st.kind === 'image' || st.kind === 'table') throw parseError(s, t, MSG_SYNTAX_ERROR);
-  if (st.textNonSpace) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
+  if (st.textNonSpace || heldNonSpace(t)) throw parseError(s, t, MSG_TEXT_BEFORE_TABLE);
   const tbl = parseTable(s, fontStack);
   st.kind = 'table';
   return [tbl];
@@ -275,17 +270,15 @@ const scanAfterTable = (s: ParseState, t: Token, st: CellScan): HtmlCellContent[
 };
 
 /** `image` as the cell's only child. */
-const scanCellImage = (
-  s: ParseState, t: OpenToken, cellAttrs: Record<string, string>, st: CellScan,
-): HtmlCellContent[] => {
+const scanCellImage = (s: ParseState, t: OpenToken, st: CellScan): HtmlCellContent[] => {
   if (st.kind !== 'none') throw parseError(s, t, MSG_SYNTAX_ERROR);
   st.kind = 'image';
-  return [parseImgContent(s, t, cellAttrs)];
+  return [parseImgContent(s, t)];
 };
 
 /** One step of `cell: T_cell (fonttable | fonttext | image) T_end_cell`. */
 const scanCellItem = (
-  s: ParseState, t: Token, cellAttrs: Record<string, string>, fontStack: FontState[], st: CellScan,
+  s: ParseState, t: Token, fontStack: FontState[], st: CellScan,
 ): HtmlCellContent[] => {
   if (st.kind === 'fonttable') throw parseError(s, t, MSG_SYNTAX_ERROR);
   if (st.kind === 'table') return scanAfterTable(s, t, st);
@@ -295,7 +288,7 @@ const scanCellItem = (
     return [parseFontTable(s, wrapper, fontStack)];
   }
   if (t.type === 'open' && t.tag === 'TABLE') return scanCellTable(s, t, fontStack, st);
-  if (t.type === 'open' && t.tag === 'IMG') return scanCellImage(s, t, cellAttrs, st);
+  if (t.type === 'open' && t.tag === 'IMG') return scanCellImage(s, t, st);
   if (st.kind === 'image') throw parseError(s, t, MSG_SYNTAX_ERROR);
   return scanCellText(s, t, fontStack, st);
 };
@@ -308,14 +301,12 @@ const endsCell = (s: ParseState, t: Token, st: CellScan): boolean => {
   throw parseError(s, t, afterText ? MSG_TEXT_AFTER_TABLE : MSG_SYNTAX_ERROR);
 };
 
-const parseCellContent = (
-  s: ParseState, cellAttrs: Record<string, string>, fontStack: FontState[],
-): HtmlCellContent[] => {
+const parseCellContent = (s: ParseState, fontStack: FontState[]): HtmlCellContent[] => {
   const content: HtmlCellContent[] = [];
   const st: CellScan = { kind: 'none', textNonSpace: false, afterNonSpace: false };
   for (let t = peek(s); t !== undefined; t = peek(s)) {
     if (endsCell(s, t, st)) break;
-    content.push(...scanCellItem(s, t, cellAttrs, fontStack, st));
+    content.push(...scanCellItem(s, t, fontStack, st));
   }
   const nxt = peek(s);
   if (nxt?.type === 'close' && nxt.tag === 'TD') consume(s);
@@ -330,7 +321,7 @@ const parseCellContent = (
 /** @see lib/common/htmlparse.y:cell rule / lib/common/htmllex.c:mkCell */
 const parseCell = (
   s: ParseState, attrs: Record<string, string>, fontStack: FontState[],
-): HtmlCell => buildCell(parseCellContent(s, attrs, fontStack), attrs);
+): HtmlCell => buildCell(parseCellContent(s, fontStack), attrs);
 
 // ---------------------------------------------------------------------------
 // parseRow — parses <TR>...</TR>
@@ -479,7 +470,7 @@ const consumeRowHr = (s: ParseState, rows: HtmlRow[]): void => {
 const findFirstRealToken = (tokens: Token[], start: number): Token | undefined => {
   for (let i = start; i < tokens.length; i++) {
     const tk = tokens[i];
-    if (tk.type !== 'text' || tk.value.trim() !== '') return tk;
+    if (tk.type !== 'text' || nonSpace(tk.value)) return tk;
   }
   return undefined;
 };
@@ -487,7 +478,7 @@ const findFirstRealToken = (tokens: Token[], start: number): Token | undefined =
 const skipLeadingWs = (s: ParseState): void => {
   while (true) {
     const nxt = peek(s);
-    if (!nxt || nxt.type !== 'text' || nxt.value.trim() !== '') break;
+    if (!nxt || nxt.type !== 'text' || nonSpace(nxt.value)) break;
     consume(s);
   }
 };
@@ -518,6 +509,7 @@ const parseFontTableLabel = (s: ParseState, open: OpenToken, fontStack: FontStat
 
 const parseTableLabel = (s: ParseState, fontStack: FontState[]): HtmlLabel => {
   skipLeadingWs(s);
+  if (heldNonSpace(peek(s))) throw parseError(s, peek(s), MSG_TEXT_BEFORE_TABLE);
   const table = parseTable(s, fontStack);
   finishTableLabel(s);
   return { kind: 'table', table };
@@ -562,21 +554,16 @@ export interface ParsedHtmlLabel {
 }
 
 /**
- * Parse an HTML-like label string, printing the lexer's warnings (one
- * `writeLine` per stderr line, `console.warn` by default) as the parser reaches
- * their tokens. Input is the content between the outer `<` `>` delimiters
- * (already stripped).
+ * Parse an HTML-like label string, writing the lexer's warnings to `stderr` as
+ * the parser reaches their tokens. The caller owns `stderr` and flushes it: a
+ * warning without a newline continues into the caller's next write. Input is
+ * the content between the outer `<` `>` delimiters (already stripped).
  *
  * @see lib/common/htmlparse.y:parseHTML
  */
-export const parseHtmlLabelRv = (
-  src: string,
-  writeLine: (line: string) => void = (line) => console.warn(line),
-): ParsedHtmlLabel => {
+export const parseHtmlLabelRv = (src: string, stderr: StderrLines): ParsedHtmlLabel => {
   const { tokens, error, eof } = tokenizeDeferred(`<HTML>${src}</HTML>`, { start: 6, end: 6 + src.length });
-  const s: ParseState = {
-    tokens, pos: 0, pending: error, stderr: new StderrLines(writeLine), emitted: new WeakSet(), warn: false, eof,
-  };
+  const s: ParseState = { tokens, pos: 0, pending: error, stderr, emitted: new WeakSet(), warn: false, eof };
   try {
     const label = parseTokens(s);
     if (error !== undefined) throw error;
@@ -585,8 +572,6 @@ export const parseHtmlLabelRv = (
     // Running off the truncated stream means C's lexer would have hit the error.
     if (error !== undefined && s.pos >= tokens.length) { emitEof(s); throw error; }
     throw e;
-  } finally {
-    s.stderr?.flush();
   }
 };
 
@@ -596,4 +581,4 @@ export const parseHtmlLabelRv = (
  * the sync pass prints.
  */
 export const parseHtmlLabel = (src: string): HtmlLabel =>
-  parseHtmlLabelRv(src, () => undefined).label;
+  parseHtmlLabelRv(src, new StderrLines(() => undefined)).label;

package/src/common/htmltable-pos.ts

@@ -16,14 +16,11 @@
  */
 
 import type { Box } from '../model/geom.js';
-import type { TextlabelT } from './types.js';
 import type { TextMeasurer } from './textmeasure.js';
-import type { HtmlCell, HtmlImage, HtmlLabel, HtmlTable, HtmlText, ImageSizer } from './htmltable-types.js';
+import type { HtmlCell, HtmlImage, HtmlLabel, HtmlTable, HtmlText } from './htmltable-types.js';
 import {
-  layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabelRv, inheritTablePenColor, withTableFont,
+  layoutHtmlTable, cellPad, cellBorder, withTableFont,
 } from './htmltable.js';
-import { makeLabel } from './make-label.js';
-import { HtmlLexError } from './htmltable-lex.js';
 import { TOP, BOTTOM, LEFT, RIGHT } from './splines-constants.js';
 import type { PlacedLine, HtmlFontInfo } from './htmltable-pos-runs.js';
 import {
@@ -171,15 +168,14 @@ export interface PlacedHtml {
  * of pos_html_cell: LEFT flushes the box right edge in (`ur.x -= delx`), RIGHT
  * flushes the left edge in, default splits (center); VALIGN BOTTOM/TOP flush,
  * default centers on BOTH axes. Parallels the existing `alignImageBox`, but
- * text default-centers vertically where an image does not.
- * (`parseAlign` never yields HALIGN_TEXT, so the cell box always shrinks here —
- * exactly what C does for every non-TEXT cell.)
+ * text default-centers vertically where an image does not. ALIGN="TEXT" keeps
+ * the box's width: lines then align across the whole cell.
  * @see lib/common/htmltable.c:pos_html_cell (text branch, :1487-1526)
  */
 export function alignContentBox(box: Box, cell: HtmlCell, w: number, h: number): Box {
   const out: Box = { ll: { ...box.ll }, ur: { ...box.ur } };
   const delx = out.ur.x - out.ll.x - w;
-  if (delx > 0) {
+  if (delx > 0 && cell.align !== 'text') {
     if (cell.align === 'left') out.ur.x -= delx;
     else if (cell.align === 'right') out.ll.x += delx;
     else { out.ll.x += delx / 2; out.ur.x -= delx / 2; }
@@ -520,82 +516,3 @@ export function posHtmlLabel(
   if (label.kind === 'table') return withTableFont(env, label.table.font, 'emit', () => posHtmlTable(label.table, env, measurer));
   return posTextLabel(label, finfo, measurer);
 }
-
-/** parseHTML's rv for a label that failed to parse (`ctx->error`). */
-const HTML_PARSE_FATAL = 3;
-
-/** A built HTML label plus make_html_label's "problem" return value. */
-export interface HtmlLabelResult {
-  label: TextlabelT;
-  rv: number;
-}
-
-/**
- * make_html_label: parse, size and position an HTML-like label. Returns C's
- * rv too (nonzero: the caller appends `in label of ...`, labels.c:make_label).
- * Parse diagnostics print here, once per label, as parseHTML does. The
- * optional `imageSizer` resolves `<IMG SRC>`; absent means C's missing image.
- * @see lib/common/htmltable.c:make_html_label
- */
-export function makeHtmlLabelRv(
-  content: string,
-  finfo: HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string },
-  measurer: TextMeasurer,
-): HtmlLabelResult {
-  const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
-  let lbl: HtmlLabel, lexWarn: boolean; // lexWarn: htmllex.c's ctx->warn, rv bit 1
-  try {
-    ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content));
-  } catch (e) {
-    // C aborts the HTML parse on a syntax error (YYABORT): parseHTML returns
-    // rv 3 (ctx->error) with no label, and make_html_label returns it with
-    // lp->html cleared and no spans, so the label renders empty.
-    // @see lib/common/htmltable.c:1880 (rv == 3), htmlparse.y (YYABORT)
-    if (e instanceof HtmlLexError) for (const line of e.diagnostics) console.error(line);
-    return { label: makeLabel('', fontname, fontsize, fontcolor, measurer), rv: HTML_PARSE_FATAL };
-  }
-  // A top-level table with no explicit COLOR inherits the object's pen color,
-  // which then flows table->cell->nested-table.
-  // @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,
-  });
-  const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
-  const dim = lbl.dimen ?? { w: 0, h: 0 };
-  // C replaces table-label text: "this may be used for the title and
-  // alt fields in image maps" — anchors inherit it as default tooltip.
-  // @see lib/common/htmltable.c:make_html_label (line 1935)
-  const text = lbl.kind === 'table' ? '<TABLE>' : content;
-  return { label: htmlTextLabel(text, { fontname, fontsize, fontcolor }, placed, dim), rv };
-}
-
-/** {@link makeHtmlLabelRv} without the problem flag. */
-export function makeHtmlLabel(
-  content: string,
-  finfo: HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string },
-  measurer: TextMeasurer,
-): TextlabelT {
-  return makeHtmlLabelRv(content, finfo, measurer).label;
-}
-
-/** Build the TextlabelT wrapper around a positioned HTML label. */
-function htmlTextLabel(
-  text: string,
-  finfo: HtmlFontInfo,
-  placed: PlacedHtml,
-  dim: { w: number; h: number },
-): TextlabelT {
-  return {
-    text,
-    fontname: finfo.fontname, fontcolor: finfo.fontcolor, charset: 0,
-    fontsize: finfo.fontsize,
-    dimen: { x: dim.w, y: dim.h },
-    space: { x: dim.w, y: dim.h },
-    pos: { x: 0, y: 0 },
-    u: { kind: 'html', html: placed },
-    valign: 'c'.charCodeAt(0),
-    set: false,
-    html: true,
-  };
-}

package/src/common/htmltable-types.ts

@@ -40,6 +40,9 @@ export class HtmlParseError extends DotEngineError {
 /** @see lib/common/htmltable.h HALIGN_* flags */
 export type HtmlAlign = 'left' | 'center' | 'right';
 
+/** A cell's ALIGN: TEXT (HALIGN_TEXT) leaves the text block the cell's width. @see lib/common/htmllex.c:cell_halignfn */
+export type HtmlCellAlign = HtmlAlign | 'text';
+
 /** @see lib/common/htmltable.h VALIGN_* flags */
 export type HtmlVAlign = 'top' | 'middle' | 'bottom';
 
@@ -132,7 +135,7 @@ export interface HtmlCell {
    */
   vruled?: boolean;
   port?: string;
-  align?: HtmlAlign;
+  align?: HtmlCellAlign;
   valign?: HtmlVAlign;
   balign?: HtmlAlign;
   bgcolor?: string;
@@ -275,6 +278,8 @@ export interface OpenToken extends LexerOutput {
   type: 'open';
   tag: string;
   attrs: Record<string, string>;
+  /** On a TABLE: `ctx->xb` text no token carried, read by the table rule's nonSpace. */
+  heldText?: string;
 }
 
 /** @see lib/common/htmllex.c:endElement */

package/src/common/htmltable.ts

@@ -20,13 +20,13 @@ export type { TextMeasurer } from './textmeasure.js';
 
 import type {
   HtmlCell, HtmlCellContent, HtmlImage, HtmlLabel, HtmlTable, HtmlText,
-  HtmlTextItem,
+  HtmlTextItem, ImageSizer,
 } from './htmltable-types.js';
-import type { ImageSizer } from './htmltable-types.js';
 import { findImageSize } from '../gvc/usershape.js';
 import { PointSet } from './pointset.js';
 import type { TextMeasurer } from './textmeasure.js';
 import { withTableFont } from './htmltable-fontinfo.js';
+import { agerrLine, type StderrLines } from './htmltable-attr-warn.js';
 
 export { withTableFont } from './htmltable-fontinfo.js';
 
@@ -85,6 +85,7 @@ export interface HtmlSizeEnv {
   fontsize: number;
   fontname: string;
   imageSizer?: ImageSizer;
+  stderr?: StderrLines; // the label's stderr; none: straight to the console
 }
 
 const defaultSizeEnv = (): HtmlSizeEnv => ({ fontsize: DEFAULT_FONTSIZE, fontname: '' });
@@ -230,21 +231,20 @@ const sizeTextContent = (
 /** Images whose sizing failed: size_html_img's rv = 1 on every later call. */
 const missingImages = new WeakSet<HtmlImage>();
 
-const sizeHtmlImg = (img: HtmlImage, imageSizer?: ImageSizer): number => {
+const sizeHtmlImg = (img: HtmlImage, { imageSizer, stderr }: HtmlSizeEnv): number => {
   // C sizes each image once (processTbl); the port's size and pos passes
   // share layoutHtmlTable, so guard against re-sizing (and re-warning). The
   // returned rv still follows C on every call.
   if (img.width !== undefined && img.height !== undefined) return missingImages.has(img) ? 1 : 0;
   const sz = imageSizer !== undefined ? imageSizer(img.src) : findImageSize(img.src);
   if (sz !== null) {
-    img.width = sz.w;
-    img.height = sz.h;
+    img.width = sz.w; img.height = sz.h;
     return 0;
   }
   // Missing-image: zero size + warning.
   // C: agerrorf("No or improper image file=\"%s\"\n", img->src) — agerr
   // prefixes "Error: " on stderr.
-  console.error(`Error: No or improper image file="${img.src}"`);
+  agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
   missingImages.add(img);
@@ -262,7 +262,7 @@ const sizeContentItem = (
     return { ...(item.dimen !== undefined ? item.dimen : { w: 0, h: 0 }), rv };
   }
   if (item.kind === 'image') {
-    const rv = sizeHtmlImg(item, env.imageSizer);
+    const rv = sizeHtmlImg(item, env);
     return { w: item.width ?? 0, h: item.height ?? 0, rv };
   }
   return { w: 0, h: 0, rv: 0 };
@@ -327,15 +327,15 @@ const sizeWarned = new WeakSet<object>();
  * @see lib/common/htmltable.c:1141 (size_html_cell FIXED_FLAG)
  */
 const fixedCellCheck = (
-  cell: HtmlCell, sz: { w: number; h: number }, warn: boolean,
+  cell: HtmlCell, sz: { w: number; h: number }, warn: boolean, out: StderrLines | undefined,
 ): { rv: number; zero: boolean } => {
   if (!cell.fixedsize) return { rv: 0, zero: false };
   if (cell.width && cell.height) {
     const small = (cell.width < sz.w || cell.height < sz.h) && cell.content[0]?.kind !== 'image';
-    if (small && warn) console.warn(WARN_CELL_TOO_SMALL);
+    if (small && warn) agerrLine(out, WARN_CELL_TOO_SMALL);
     return { rv: small ? 1 : 0, zero: true };
   }
-  if (warn) console.warn(WARN_CELL_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_CELL_UNSPECIFIED);
   return { rv: 1, zero: false };
 };
 
@@ -360,7 +360,7 @@ const getCellSize = (
   let szy = ch + margin;
   const warn = !sizeWarned.has(cell);
   sizeWarned.add(cell);
-  const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn);
+  const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn, env.stderr);
   rv |= fixed.rv;
   if (fixed.zero) { szx = 0; szy = 0; }
   const bw = cell.width !== undefined ? cell.width : 0;
@@ -504,16 +504,16 @@ export const layoutHtmlTable = (
  * table, the returned `rv = 1` follows C on every call.
  * @see lib/common/htmltable.c:size_html_tbl (:1683, :1689)
  */
-const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }): number => {
+const warnFixedTable = (tbl: HtmlTable, dims: { wd: number; ht: number }, out: StderrLines | undefined): number => {
   const warn = !sizeWarned.has(tbl);
   sizeWarned.add(tbl);
   if (tbl.fixedsize !== true) return 0;
   if (tbl.width && tbl.height) {
     if (tbl.width >= dims.wd && tbl.height >= dims.ht) return 0;
-    if (warn) console.warn(WARN_TABLE_TOO_SMALL);
+    if (warn) agerrLine(out, WARN_TABLE_TOO_SMALL);
     return 1;
   }
-  if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
+  if (warn) agerrLine(out, WARN_TABLE_UNSPECIFIED);
   return 1;
 };
 
@@ -525,7 +525,7 @@ const sizeTableBody = (
 ): number => {
   const { entries, widths, heights, spacing, border, rv } = layoutHtmlTable(tbl, measurer, env);
   if (entries.length === 0) {
-    const fixed = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border }));
+    const fixed = warnFixedTable(tbl, sumTableDims({ widths, heights, ncols: 0, nrows: 0, spacing, border }), env.stderr);
     tbl.dimen = { w: 0, h: 0 };
     return rv | fixed;
   }
@@ -535,7 +535,7 @@ const sizeTableBody = (
   const { wd, ht } = sumTableDims({ widths, heights, ncols, nrows, spacing, border });
   const baseWd = tbl.width !== undefined ? tbl.width : 0;
   const baseHt = tbl.height !== undefined ? tbl.height : 0;
-  const fixed = warnFixedTable(tbl, { wd, ht });
+  const fixed = warnFixedTable(tbl, { wd, ht }, env.stderr);
   // C zeroes only the CONTENT-derived term for a FIXEDSIZE table that has BOTH
   // width and height, so the box becomes fmax(0, width)=width / fmax(0,height)=
   // height (the explicit size). A fixed table missing a dimension warns and

package/src/common/make-label.ts

@@ -12,7 +12,8 @@
 import type { TextlabelT } from './types.js';
 import type { TextMeasurer, TextSize } from './textmeasure.js';
 import type { TextSpan } from './emit-types.js';
-import { makeHtmlLabelRv } from './htmltable-pos.js';
+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 { Graph } from '../model/graph.js';
@@ -205,8 +206,12 @@ export function makeAnyLabel(
     // 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 { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
-    if (rv !== 0 && obj !== undefined) console.error(inLabelOf(obj));
+    // 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);
+    if (rv !== 0 && obj !== undefined) stderr.write(`${inLabelOf(obj)}\n`);
+    stderr.flush();
     return label;
   }
   // Plain path: resolve \G \N \E \T \H \L against the owning object