@knowvah/dot-engine 2.6.2 → 2.6.4

package/src/common/htmltable-pos.ts

@@ -19,8 +19,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 { layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabel } from './htmltable.js';
+import {
+  layoutHtmlTable, cellPad, cellBorder, sizeHtmlLabel, parseHtmlLabel, inheritTablePenColor,
+} 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 {
@@ -517,57 +520,44 @@ export function posHtmlLabel(
   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;
+}
+
 /**
- * Build a TextlabelT for an HTML label string: parse, size, position.
- * Falls back to a plain-text label on parse failure (C reverts to the
- * object name; we keep the markup text).
- *
- * The optional `imageSizer` on `finfo` resolves `<IMG SRC="..."/>` dims.
- * Absent → C missing-image behavior (zero size + warning).
- *
+ * 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
  */
-/**
- * Propagate pen (border) color down the table tree. A table with no explicit
- * COLOR inherits `parentColor`; each cell inherits the (possibly inherited)
- * table color; each nested table inherits its enclosing cell's color. Mirrors
- * C, which defaults the top table's pencolor to getPenColor(obj) then copies
- * parent->child during processTbl.
- * @see lib/common/htmltable.c:1911 (top table), :1406-1407 (cell), :1556-1557
- */
-function inheritTablePenColor(tbl: HtmlTable, parentColor: string | undefined): void {
-  if (tbl.color === undefined) tbl.color = parentColor;
-  const tblColor = tbl.color;
-  for (const row of tbl.rows) {
-    for (const cell of row.cells) {
-      if (cell.color === undefined) cell.color = tblColor;
-      for (const item of cell.content) {
-        if (item.kind === 'table') inheritTablePenColor(item, cell.color);
-      }
-    }
-  }
-}
-
-export function makeHtmlLabel(
+export function makeHtmlLabelRv(
   content: string,
   finfo: HtmlFontInfo & { imageSizer?: ImageSizer; pencolor?: string },
   measurer: TextMeasurer,
-): TextlabelT {
+): HtmlLabelResult {
   const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
   let lbl: HtmlLabel;
   try {
     lbl = parseHtmlLabel(content);
-  } catch {
-    // C aborts the HTML parse on a syntax error (YYABORT) and leaves the label
-    // EMPTY — it does not fall back to rendering the raw markup as plain text.
-    // @see lib/common/htmlparse.y (cleanup + YYABORT), htmllex.c htmlerror
-    return makeLabel('', fontname, fontsize, fontcolor, measurer);
+  } 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);
-  sizeHtmlLabel(lbl, measurer, {
+  const rv = sizeHtmlLabel(lbl, measurer, {
     fontsize, fontname, imageSizer,
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
@@ -576,7 +566,16 @@ export function makeHtmlLabel(
   // 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 htmlTextLabel(text, { fontname, fontsize, fontcolor }, placed, dim);
+  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. */

package/src/common/htmltable.ts

@@ -24,6 +24,7 @@ import type {
 } 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';
 
 const DEFAULT_BORDER = 1;
@@ -45,25 +46,29 @@ interface TableDimArgs {
 
 /** @see lib/common/htmltable.c:findCol */
 const findCol = (
-  used: Set<string>,
+  ps: PointSet,
   row: number,
   startCol: number,
   colspan: number,
   rowspan: number,
 ): number => {
   let col = startCol;
-  for (;;) {
-    let conflict = false;
-    for (let c = col; c < col + colspan && !conflict; c++) {
-      for (let r = row; r < row + rowspan && !conflict; r++) {
-        if (used.has(`${c},${r}`)) { conflict = true; col = c + 1; }
-      }
+  let notFound = true;
+  const end = colspan - 1;
+  while (notFound) {
+    const lastc = col + end;
+    let c: number;
+    for (c = lastc; c >= col; c--) {
+      if (ps.isInPS(c, row)) break;
+    }
+    if (c >= col) col = c + 1; // conflict: try column after
+    else notFound = false;
+  }
+  for (let j = col; j < col + colspan; j++) {
+    for (let i = row; i < row + rowspan; i++) {
+      ps.addPS(j, i);
     }
-    if (!conflict) break;
   }
-  for (let c = col; c < col + colspan; c++)
-    for (let r = row; r < row + rowspan; r++)
-      used.add(`${c},${r}`);
   return col;
 };
 
@@ -219,15 +224,19 @@ const sizeTextContent = (
  *
  * @see lib/common/htmltable.c:size_html_img (line 1080)
  */
-const sizeHtmlImg = (img: HtmlImage, imageSizer?: ImageSizer): void => {
+/** 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 => {
   // C sizes each image once (processTbl); the port's size and pos passes
-  // share layoutHtmlTable, so guard against re-sizing (and re-warning).
-  if (img.width !== undefined && img.height !== undefined) return;
+  // 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;
-    return;
+    return 0;
   }
   // Missing-image: zero size + warning.
   // C: agerrorf("No or improper image file=\"%s\"\n", img->src) — agerr
@@ -235,23 +244,25 @@ const sizeHtmlImg = (img: HtmlImage, imageSizer?: ImageSizer): void => {
   console.error(`Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
+  missingImages.add(img);
+  return 1;
 };
 
 const sizeContentItem = (
   item: HtmlCellContent,
   measurer: TextMeasurer,
   env: HtmlSizeEnv,
-): { w: number; h: number } => {
-  if (item.kind === 'text') return sizeTextContent([item], measurer, env);
+): { w: number; h: number; rv: number } => {
+  if (item.kind === 'text') return { ...sizeTextContent([item], measurer, env), rv: 0 };
   if (item.kind === 'table') {
-    sizeTableInner(item, measurer, env);
-    return item.dimen !== undefined ? item.dimen : { w: 0, h: 0 };
+    const rv = sizeTableInner(item, measurer, env);
+    return { ...(item.dimen !== undefined ? item.dimen : { w: 0, h: 0 }), rv };
   }
   if (item.kind === 'image') {
-    sizeHtmlImg(item, env.imageSizer);
-    return { w: item.width ?? 0, h: item.height ?? 0 };
+    const rv = sizeHtmlImg(item, env.imageSizer);
+    return { w: item.width ?? 0, h: item.height ?? 0, rv };
   }
-  return { w: 0, h: 0 };
+  return { w: 0, h: 0, rv: 0 };
 };
 
 export const cellPad = (cell: HtmlCell, tbl: HtmlTable): number =>
@@ -273,32 +284,85 @@ export const cellBorder = (cell: HtmlCell, tbl: HtmlTable): number => {
   return DEFAULT_BORDER;
 };
 
+/**
+ * Propagate pen (border) color down the table tree. A table with no explicit
+ * COLOR inherits `parentColor`; each cell inherits the (possibly inherited)
+ * table color; each nested table inherits its enclosing cell's color. Mirrors
+ * C, which defaults the top table's pencolor to getPenColor(obj) then copies
+ * parent->child during processTbl.
+ * @see lib/common/htmltable.c:1911 (top table), :1406-1407 (cell), :1556-1557
+ */
+export function inheritTablePenColor(tbl: HtmlTable, parentColor: string | undefined): void {
+  if (tbl.color === undefined) tbl.color = parentColor;
+  const tblColor = tbl.color;
+  for (const row of tbl.rows) {
+    for (const cell of row.cells) {
+      if (cell.color === undefined) cell.color = tblColor;
+      for (const item of cell.content) {
+        if (item.kind === 'table') inheritTablePenColor(item, cell.color);
+      }
+    }
+  }
+}
+
+/** C `agwarningf` text as rendered on stderr ("Warning: " prefix, no newline). */
+const WARN_CELL_TOO_SMALL = 'Warning: cell size too small for content';
+const WARN_CELL_UNSPECIFIED = 'Warning: fixed cell size with unspecified width or height';
+const WARN_TABLE_TOO_SMALL = 'Warning: table size too small for content';
+const WARN_TABLE_UNSPECIFIED = 'Warning: fixed table size with unspecified width or height';
+
+/**
+ * C sizes each cell/table exactly once; the port's size and pos passes both
+ * run layoutHtmlTable, so the size warnings are emitted on first sight only.
+ */
+const sizeWarned = new WeakSet<object>();
+
+/**
+ * FIXED_FLAG branch of size_html_cell: C's rv (set at the warning sites; the
+ * warning itself is printed once per cell) and whether the content size is
+ * zeroed.
+ * @see lib/common/htmltable.c:1141 (size_html_cell FIXED_FLAG)
+ */
+const fixedCellCheck = (
+  cell: HtmlCell, sz: { w: number; h: number }, warn: boolean,
+): { 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);
+    return { rv: small ? 1 : 0, zero: true };
+  }
+  if (warn) console.warn(WARN_CELL_UNSPECIFIED);
+  return { rv: 1, zero: false };
+};
+
 /** @see lib/common/htmltable.c:size_html_cell */
 const getCellSize = (
   cell: HtmlCell,
   tbl: HtmlTable,
   measurer: TextMeasurer,
   env: HtmlSizeEnv,
-): { w: number; h: number } => {
+): { w: number; h: number; rv: number } => {
   const margin = 2 * (cellPad(cell, tbl) + cellBorder(cell, tbl));
-  let cw = 0, ch = 0;
+  let cw = 0, ch = 0, rv = 0;
   for (const item of cell.content) {
     const s = sizeContentItem(item, measurer, env);
-    cw = Math.max(cw, s.w); ch += s.h;
+    cw = Math.max(cw, s.w); ch += s.h; rv |= s.rv;
   }
   // C: sz = content + margin; FIXED_FLAG with both width and height set zeroes
   // sz (content size is ignored), then the box clamps UP to width/height via
   // MAX below — so a fixed cell ends up exactly width x height, NOT 0 x 0.
-  // (C also warns "cell size too small for content" / "unspecified"; non-visual.)
   // @see lib/common/htmltable.c:size_html_cell (FIXED_FLAG branch + box.UR MAX)
   let szx = cw + margin;
   let szy = ch + margin;
-  if (cell.fixedsize && cell.width && cell.height) {
-    szx = 0; szy = 0;
-  }
+  const warn = !sizeWarned.has(cell);
+  sizeWarned.add(cell);
+  const fixed = fixedCellCheck(cell, { w: szx, h: szy }, warn);
+  rv |= fixed.rv;
+  if (fixed.zero) { szx = 0; szy = 0; }
   const bw = cell.width !== undefined ? cell.width : 0;
   const bh = cell.height !== undefined ? cell.height : 0;
-  return { w: Math.max(szx, bw), h: Math.max(szy, bh) };
+  return { w: Math.max(szx, bw), h: Math.max(szy, bh), rv };
 };
 
 /** @see lib/common/htmltable.c:processTbl */
@@ -306,9 +370,10 @@ const buildLayouts = (
   tbl: HtmlTable,
   measurer: TextMeasurer,
   env: HtmlSizeEnv,
-): CellEntry[] => {
+): { entries: CellEntry[]; rv: number } => {
   const entries: CellEntry[] = [];
-  const used = new Set<string>();
+  let rv = 0;
+  const ps = new PointSet();
   let rowIdx = 0;
   for (const row of tbl.rows) {
     let col = 0;
@@ -316,14 +381,15 @@ const buildLayouts = (
       if (c.kind !== 'cell') { continue; }
       const colspan = c.colspan !== undefined ? c.colspan : 1;
       const rowspan = c.rowspan !== undefined ? c.rowspan : 1;
-      const { w, h } = getCellSize(c, tbl, measurer, env);
-      col = findCol(used, rowIdx, col, colspan, rowspan);
+      const { w, h, rv: cellRv } = getCellSize(c, tbl, measurer, env);
+      rv |= cellRv;
+      col = findCol(ps, rowIdx, col, colspan, rowspan);
       entries.push({ cell: c, row: rowIdx, col, colspan, rowspan, w, h });
       col += colspan;
     }
     rowIdx++;
   }
-  return entries;
+  return { entries, rv };
 };
 
 /** @see lib/common/htmltable.c:set_cell_widths */
@@ -403,6 +469,8 @@ export interface HtmlTableLayout {
   heights: number[];
   spacing: number;
   border: number;
+  /** processTbl's return: nonzero when sizing any cell had a problem. */
+  rv: number;
 }
 
 /**
@@ -417,15 +485,33 @@ export const layoutHtmlTable = (
 ): HtmlTableLayout => {
   const spacing = getSpacing(tbl);
   const border = getBorder(tbl);
-  const entries = buildLayouts(tbl, measurer, env);
+  const { entries, rv } = buildLayouts(tbl, measurer, env);
   if (entries.length === 0) {
-    return { entries, widths: [], heights: [], spacing, border };
+    return { entries, widths: [], heights: [], spacing, border, rv };
   }
   const ncols = Math.max(...entries.map(e => e.col + e.colspan));
   const nrows = Math.max(...entries.map(e => e.row + e.rowspan));
   const widths = setColWidths(entries, ncols, spacing);
   const heights = setRowHeights(entries, nrows, spacing);
-  return { entries, widths, heights, spacing, border };
+  return { entries, widths, heights, spacing, border, rv };
+};
+
+/**
+ * FIXED_FLAG diagnostics of size_html_tbl: the warning is emitted once per
+ * 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 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);
+    return 1;
+  }
+  if (warn) console.warn(WARN_TABLE_UNSPECIFIED);
+  return 1;
 };
 
 /** @see lib/common/htmltable.c:size_html_tbl */
@@ -433,15 +519,20 @@ const sizeTableInner = (
   tbl: HtmlTable,
   measurer: TextMeasurer,
   env: HtmlSizeEnv,
-): void => {
-  const { entries, widths, heights, spacing, border } = layoutHtmlTable(tbl, measurer, env);
-  if (entries.length === 0) { tbl.dimen = { w: 0, h: 0 }; return; }
+): 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 }));
+    tbl.dimen = { w: 0, h: 0 };
+    return rv | fixed;
+  }
   const ncols = Math.max(...entries.map(e => e.col + e.colspan));
   const nrows = Math.max(...entries.map(e => e.row + e.rowspan));
   for (const e of entries) e.cell.dimen = { w: e.w, h: e.h };
   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 });
   // 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
@@ -452,6 +543,7 @@ const sizeTableInner = (
     w: Math.max(zeroContent ? 0 : wd, baseWd),
     h: Math.max(zeroContent ? 0 : ht, baseHt),
   };
+  return rv | fixed;
 };
 
 /**
@@ -461,17 +553,19 @@ const sizeTableInner = (
  * When absent or when the sizer returns null, images get zero size and a
  * warning is emitted, matching C's missing-image behavior exactly.
  *
+ * @returns make_html_label's `rv |= size_html_*`: nonzero on a sizing problem.
  * @see lib/common/htmltable.c:make_html_label
  */
 export const sizeHtmlLabel = (
   label: HtmlLabel,
   measurer: TextMeasurer,
   env: HtmlSizeEnv = DEFAULT_SIZE_ENV,
-): void => {
+): number => {
   if (label.kind === 'table') {
-    sizeTableInner(label.table, measurer, env);
+    const rv = sizeTableInner(label.table, measurer, env);
     label.dimen = label.table.dimen;
-  } else {
-    label.dimen = sizeTextContent(label.texts, measurer, env);
+    return rv;
   }
+  label.dimen = sizeTextContent(label.texts, measurer, env);
+  return 0; // size_html_txt always returns 0
 };

package/src/common/make-label.ts

@@ -12,10 +12,10 @@
 import type { TextlabelT } from './types.js';
 import type { TextMeasurer, TextSize } from './textmeasure.js';
 import type { TextSpan } from './emit-types.js';
-import { makeHtmlLabel } from './htmltable-pos.js';
+import { makeHtmlLabelRv } from './htmltable-pos.js';
 import { substObj, type GraphObj } from './subst.js';
 import { Edge } from '../model/edge.js';
-import type { Graph } from '../model/graph.js';
+import { Graph } from '../model/graph.js';
 import { htmlEntityUTF8 } from './html-entities.js';
 
 export const DEFAULT_FONTSIZE = 14.0;
@@ -48,6 +48,20 @@ function rootOf(obj: GraphObj): Graph {
   return obj instanceof Edge ? obj.tail.root : obj.root;
 }
 
+/**
+ * The `agerr(AGPREV, ...)` continuation make_label prints when
+ * make_html_label reports a problem (no `Error:`/`Warning:` prefix).
+ * @see lib/common/labels.c:make_label (148-163)
+ */
+function inLabelOf(obj: GraphObj): string {
+  if (obj instanceof Edge) {
+    const sep = obj.head.root.kind.endsWith('undirected') ? '--' : '->';
+    return `in label of edge ${obj.tail.name} ${sep} ${obj.head.name}`;
+  }
+  if (obj instanceof Graph) return `in label of graph ${obj.name}`;
+  return `in label of node ${obj.name}`;
+}
+
 /** Font attributes bundle — mirrors C fontinfo_t fields used in label init. */
 export interface FontInfo {
   fontname: string;
@@ -191,7 +205,9 @@ 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;
-    return makeHtmlLabel(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
+    const { label, rv } = makeHtmlLabelRv(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer);
+    if (rv !== 0 && obj !== undefined) console.error(inLabelOf(obj));
+    return label;
   }
   // Plain path: resolve \G \N \E \T \H \L against the owning object
   // BEFORE measuring, as C does (labels.c:169, escBackslash=0; the

package/src/common/spline-midpoint.ts

@@ -14,20 +14,41 @@ import { fma } from './fma.js';
 type BezLike = { list: Point[]; sflag: number; eflag: number; sp: Point; ep: Point; size?: number };
 export type SplLike = { list: BezLike[] };
 
+/**
+ * DIST2(p, q) as the oracle compiles it. clang -ffp-contract=on turns
+ * `dx*dx + dy*dy` into `fmul t, dy, dy; fmadd d, dx, dx, t` at every libgvc
+ * site the port reaches through here: dotneato_closest's scan and bisection,
+ * edgeMidpoint's APPROXEQPT and polylineMidpoint's DIST (libgvc 16.1
+ * disassembly), and resolvePort's inlined closestSide.
+ * @see lib/common/geom.h:DIST2
+ */
 export function dist2(p: Point, q: Point): number {
   const dx = p.x - q.x; const dy = p.y - q.y;
-  return dx * dx + dy * dy;
+  return fma(dx, dx, dy * dy);
 }
 
+/** DIST: sqrt of the fused DIST2 (`fmadd` then `fsqrt`). @see lib/common/geom.h:DIST */
 function distPt(p: Point, q: Point): number { return Math.sqrt(dist2(p, q)); }
 
-function evalBez4(pts: Point[], t: number): Point {
-  const u = 1 - t;
-  const [p0, p1, p2, p3] = pts;
-  return {
-    x: u*u*u*p0.x + 3*u*u*t*p1.x + 3*u*t*t*p2.x + t*t*t*p3.x,
-    y: u*u*u*p0.y + 3*u*u*t*p1.y + 3*u*t*t*p2.y + t*t*t*p3.y,
-  };
+/**
+ * Point at t on a cubic: C's de Casteljau triangle. Each
+ * `(1.0 - t) * a + t * b` compiles to `fmul v, b, t; fmla v, a, 1-t`, i.e.
+ * fma(a, 1 - t, t * b), both in Bezier itself and where dotneato_closest
+ * inlines it (libgvc 16.1 disassembly). The Left/Right halves are not needed
+ * here, so only the apex is kept.
+ * @see lib/common/utils.c:Bezier
+ */
+function bezier(v: Point[], t: number): Point {
+  const u = 1.0 - t;
+  const x = [v[0].x, v[1].x, v[2].x, v[3].x];
+  const y = [v[0].y, v[1].y, v[2].y, v[3].y];
+  for (let i = 1; i <= 3; i++) {
+    for (let j = 0; j <= 3 - i; j++) {
+      x[j] = fma(x[j], u, t * x[j + 1]);
+      y[j] = fma(y[j], u, t * y[j + 1]);
+    }
+  }
+  return { x: x[0], y: y[0] };
 }
 
 /** @see lib/common/utils.c:dotneato_closest */
@@ -55,7 +76,7 @@ export function dotneatoClosest(spl: SplLike, pt: Point): Point {
   let pt2: Point;
   for (;;) {
     const t = (lo + hi) / 2.0;
-    pt2 = evalBez4(c, t);
+    pt2 = bezier(c, t);
     if (Math.abs(dlo2 - dhi2) < 1.0 || Math.abs(hi - lo) < 0.00001) break;
     if (dlo2 < dhi2) { hi = t; dhi2 = dist2(pt2, pt); }
     else { lo = t; dlo2 = dist2(pt2, pt); }

package/src/label/node.ts

@@ -176,14 +176,20 @@ function updatePickBest(best: PickBest, i: number, area: number, increase: bigin
   }
 }
 
-/** Smallest rect enclosing all occupied branch rects. @see label/node.c:NodeCover */
+/**
+ * Smallest rect enclosing all occupied branch rects.
+ * C's `r = n->branch[i].rect` copies the Rect_t; returning the branch's own
+ * object let a parent branch share it, and a later InitNode of either node
+ * (split) zeroed both, so RTreeSearch pruned a live subtree.
+ * @see label/node.c:NodeCover
+ */
 export function nodeCover(n: Node): Rect {
   let r: Rect = { boundary: [0, 0, 0, 0] };
   initRect(r);
   let flag = true;
   for (let i = 0; i < NODECARD; i++) {
     if (n.branch[i].child !== null) {
-      if (flag) { r = n.branch[i].rect; flag = false; }
+      if (flag) { r = { boundary: [...n.branch[i].rect.boundary] }; flag = false; }
       else { r = combineRect(r, n.branch[i].rect); }
     }
   }

package/src/layout/circo/position-helpers.ts

@@ -12,12 +12,18 @@
 import type { Node } from '../../model/node.js';
 import type { Block } from './blocks.js';
 import { isCoalesced } from './blocks.js';
+import { fma } from '../../common/fma.js';
+import { libmHypot } from '../../common/libm-hypot.js';
 
-/** 2-D rotation of (x,y) by (cosR, sinR). */
+/**
+ * 2-D rotation of (x,y) by (cosR, sinR). clang contracts both lines into
+ * fmadd: X = x*cosR + (-sinR*y), Y = x*sinR + cosR*y (objdump of
+ * `_applyDelta`).
+ */
 export function rotatePoint(
   x: number, y: number, cosR: number, sinR: number,
 ): [number, number] {
-  return [x * cosR - y * sinR, x * sinR + y * cosR];
+  return [fma(x, cosR, -sinR * y), fma(x, sinR, cosR * y)];
 }
 
 /** Read psi from a node's alg field (set during Pass 4). */
@@ -27,7 +33,7 @@ export function nodePsi(n: Node): number {
 
 /** getRotation: single-node block with preset parent_pos. */
 export function rotFromParentPos(sn: Block, theta: number): number {
-  let r = theta + Math.PI - sn.parentPos;
+  let r = theta + (Math.PI - sn.parentPos); // C: theta += M_PI - parent_pos
   if (r < 0) r += 2 * Math.PI;
   return r;
 }
@@ -35,16 +41,19 @@ export function rotFromParentPos(sn: Block, theta: number): number {
 /** Find the node in sn closest to origin after translation by (x,y). */
 export function closestNode(sn: Block, x: number, y: number, skip: Node): Node {
   let best = skip;
-  let bestDist = Math.hypot(skip.info.pos![0]! + x, skip.info.pos![1]! + y);
+  let bestDist = libmHypot(skip.info.pos![0]! + x, skip.info.pos![1]! + y);
   for (const dn of sn.subGraph.nodes) {
     if (dn.orig === skip) continue;
-    const d = Math.hypot(dn.orig.info.pos![0]! + x, dn.orig.info.pos![1]! + y);
+    const d = libmHypot(dn.orig.info.pos![0]! + x, dn.orig.info.pos![1]! + y);
     if (d < bestDist) { bestDist = d; best = dn.orig; }
   }
   return best;
 }
 
-/** getRotation: COALESCED block — off-center trigonometric correction. */
+/**
+ * getRotation: COALESCED block whose neighbor lies right of -r — off-center
+ * trigonometric correction. C: `theta += M_PI / 2.0 - phi - asin(...)`.
+ */
 export function rotCoalesced(
   sn: Block, x: number, y: number, nbr: Node, theta: number,
 ): number {
@@ -52,26 +61,28 @@ export function rotCoalesced(
   const r = sn.radius - rho;
   const nx = nbr.info.pos![0]!;
   const ny = nbr.info.pos![1]!;
-  if (-r >= nx) {
-    const phi = Math.atan2(ny, nx);
-    return theta + Math.PI - phi - nodePsi(nbr);
-  }
-  const R = Math.hypot(x, y);
+  const R = libmHypot(x, y);
   const phi = Math.atan2(ny, nx + r);
   const l = r - rho / Math.cos(phi);
-  return theta + Math.PI / 2 - phi - Math.asin((l / R) * Math.cos(phi));
+  return theta + ((Math.PI / 2 - phi) - Math.asin((l / R) * Math.cos(phi)));
 }
 
-/** getRotation: general multi-node non-coalesced block. */
+/**
+ * getRotation when the neighbor is not the node closest to the parent: the
+ * coalesced correction when `COALESCED(sn) && -r < n_x`, else the
+ * origin-centred rotation `theta += M_PI - phi - PSI`, wrapped past 2*M_PI.
+ * @see lib/circogen/circpos.c:getRotation
+ */
 export function rotGeneral(
   sn: Block, x: number, y: number, nbr: Node, theta: number,
 ): number {
   if (closestNode(sn, x, y, nbr) === nbr) return 0;
-  if (isCoalesced(sn)) return rotCoalesced(sn, x, y, nbr, theta);
+  const r = sn.radius - sn.rad0;
+  if (isCoalesced(sn) && -r < nbr.info.pos![0]!) return rotCoalesced(sn, x, y, nbr, theta);
   const phi = Math.atan2(nbr.info.pos![1]!, nbr.info.pos![0]!);
-  let r = theta + Math.PI - phi - nodePsi(nbr);
-  if (r > 2 * Math.PI) r -= 2 * Math.PI;
-  return r;
+  let t = theta + ((Math.PI - phi) - nodePsi(nbr));
+  if (t > 2 * Math.PI) t -= 2 * Math.PI;
+  return t;
 }
 
 /**