@knowvah/dot-engine 0.1.0

package/src/common/make-label.ts

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Label construction for plain-text and HTML node labels.
+ * Unified entry point mirrors C labels.c:make_label which branches
+ * internally on is_html.
+ *
+ * @see lib/common/labels.c:make_label
+ * @see lib/common/htmltable.c:make_html_label
+ */
+
+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 { substObj, type GraphObj } from './subst.js';
+import { htmlEntityUTF8 } from './html-entities.js';
+
+export const DEFAULT_FONTSIZE = 14.0;
+export const DEFAULT_FONTNAME = 'Times,serif';
+export const DEFAULT_COLOR = 'black';
+
+// htmlEntityUTF8 moved to html-entities.ts (a leaf module) so the HTML lexer
+// can decode entities in text runs without an import cycle. Re-exported here
+// for existing callers. @see lib/common/utils.c:htmlEntityUTF8 / htmlEntity
+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.
+ * @see lib/common/htmltable.c:getPenColor
+ */
+function getPenColor(obj?: GraphObj): string | undefined {
+  if (obj === undefined) return undefined;
+  const pc = obj.attrs.get('pencolor');
+  if (pc !== undefined && pc !== '') return pc;
+  const c = obj.attrs.get('color');
+  if (c !== undefined && c !== '') return c;
+  return undefined;
+}
+
+/** Font attributes bundle — mirrors C fontinfo_t fields used in label init. */
+export interface FontInfo {
+  fontname: string;
+  fontsize: number;
+  fontcolor: string;
+}
+
+function buildSpan(
+  text: string,
+  font: FontInfo,
+  measured: TextSize,
+): TextSpan {
+  return {
+    str: text,
+    fontName: font.fontname,
+    fontSize: font.fontsize,
+    fontColor: font.fontcolor,
+    fontFlags: 0,
+    yoffset_layout: 0,
+    yoffset_centerline: measured.yoffsetCenterline ?? 0.05 * font.fontsize,
+    size: { x: measured.w, y: measured.h },
+    just: 'n',
+  };
+}
+
+/** One line split out of a label, with its justification terminator. */
+interface LabelLine { text: string; just: 'n' | 'l' | 'r'; }
+
+const isJust = (c: string | undefined): c is 'n' | 'l' | 'r' =>
+  c === 'n' || c === 'l' || c === 'r';
+
+/**
+ * Split label text into lines at \n / \l / \r escapes and literal
+ * newlines; the terminator becomes the line's justification. Any other
+ * escape drops its backslash and keeps the following character
+ * (including \\ → \) — the lexer delivers escapes verbatim and this
+ * is where C interprets them.
+ * @see lib/common/labels.c:make_simple_label
+ */
+export function splitLabelLines(text: string): LabelLine[] {
+  const lines: LabelLine[] = [];
+  let cur = '';
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]!;
+    if (c === '\\' && i + 1 < text.length) {
+      const e = text[++i]!;
+      if (isJust(e)) {
+        lines.push({ text: cur, just: e });
+        cur = '';
+      } else {
+        cur += e; // C default: agxbputc(&line, *p) — backslash dropped
+      }
+    } else if (c === '\n') {
+      lines.push({ text: cur, just: 'n' });
+      cur = '';
+    } else {
+      cur += c;
+    }
+  }
+  if (cur.length > 0) lines.push({ text: cur, just: 'n' });
+  return lines;
+}
+
+/** C LINESPACING — empty lines take (int)(fontsize * 1.2). @see const.h:LINESPACING */
+const LINESPACING = 1.2;
+
+/** Build one measured span for a label line. @see labels.c:storeline */
+function buildLineSpan(line: LabelLine, font: FontInfo, measurer: TextMeasurer): TextSpan {
+  const measured = line.text.length > 0
+    ? measurer.measure(line.text, font.fontname, font.fontsize)
+    : { w: 0, h: Math.trunc(font.fontsize * LINESPACING) };
+  const span = buildSpan(line.text, font, measured);
+  span.just = line.just;
+  return span;
+}
+
+/** @see lib/common/labels.c:make_simple_label / storeline */
+function makePlainLabel(
+  text: string,
+  font: FontInfo,
+  measurer: TextMeasurer,
+): TextlabelT {
+  const spans = splitLabelLines(text).map((ln) => buildLineSpan(ln, font, measurer));
+  // dimen.x = max line width; dimen.y accumulates heights; space = dimen.
+  const w = spans.reduce((a, sp) => Math.max(a, sp.size.x), 0);
+  const h = spans.reduce((a, sp) => a + sp.size.y, 0);
+  return {
+    text, ...font, charset: 0,
+    dimen: { x: w, y: h },
+    space: { x: w, y: h },
+    pos: { x: 0, y: 0 },
+    u: { kind: 'txt', span: spans, nspans: spans.length },
+    valign: 'c'.charCodeAt(0),
+    set: false, html: false,
+  };
+}
+
+/**
+ * Create a TextlabelT for a plain-text label string.
+ * @see lib/common/labels.c:make_label
+ */
+export function makeLabel(
+  text: string,
+  fontname: string,
+  fontsize: number,
+  fontcolor: string,
+  measurer: TextMeasurer,
+): TextlabelT {
+  return makePlainLabel(text, { fontname, fontsize, fontcolor }, measurer);
+}
+
+/**
+ * Unified label entry mirroring C labels.c:make_label(obj, str, kind).
+ *
+ * C branches on `kind & LT_HTML` (labels.c:145,147). isHtml is the port
+ * equivalent (aghtmlstr / HTML_STRING_MARK).
+ *
+ * Empty-string case (labels.c:119): "disregard HTML intent for empty
+ * string labels" — C: is_html &= !streq(str, "");
+ *
+ * Parse-failure fallback (htmltable.c:1884-1907): "Parse of label failed;
+ * revert to simple text label" — C sets lp->html=false and substitutes the
+ * object name. The port has no object context so it keeps the markup text,
+ * matching makeHtmlLabel's existing fallback contract.
+ *
+ * @see lib/common/labels.c:make_label
+ * @see lib/common/htmltable.c:make_html_label
+ */
+export function makeAnyLabel(
+  content: string,
+  isHtml: boolean,
+  font: FontInfo,
+  measurer: TextMeasurer,
+  obj?: GraphObj,
+): TextlabelT {
+  // labels.c:119 — is_html &= !streq(str, "");
+  if (isHtml && content !== '') {
+    // labels.c:145-161; htmltable.c:1856 — on parse failure falls back to
+    // plain text (html=false) per htmltable.c:1892. Thread the owning object's
+    // pen color so an HTML table/cell border with no explicit COLOR inherits
+    // it (htmltable.c:1911 getPenColor). @see getPenColor
+    return makeHtmlLabel(content, { ...font, pencolor: getPenColor(obj) }, measurer);
+  }
+  // Plain path: resolve \G \N \E \T \H \L against the owning object
+  // BEFORE measuring, as C does (labels.c:169, escBackslash=0; the
+  // formatting escapes \n \l \r are handled separately), then decode HTML
+  // entities (labels.c:174 htmlEntityUTF8, UTF-8 default branch).
+  const subst = obj !== undefined ? substObj(content, obj, false) : content;
+  const text = htmlEntityUTF8(subst);
+  return makePlainLabel(text, font, measurer);
+}

package/src/common/multicolor.ts

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Shared multicolor color-list parser (AD4).
+ *
+ * Ports the colorseg_t / colorsegs_t types and the parseSegs function
+ * from lib/common/emit.c.  Pure data-in / data-out — no rendering, no
+ * ObjState mutation.  Consumed by findStopColor (style-resolve.ts),
+ * stripedBox / wedgedEllipse (S1), and multicolor edges (M1).
+ *
+ * @see lib/common/emit.c:411 colorseg_t
+ * @see lib/common/emit.c:422 colorsegs_t
+ * @see lib/common/emit.c:470 parseSegs
+ */
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * One color segment in a colon-separated color list.
+ * @see lib/common/emit.c:411 colorseg_t
+ */
+export interface ColorSeg {
+  /** Color name/spec; null when the token was empty. */
+  color: string | null;
+  /** Fractional width of this segment in [0, 1]. */
+  t: number;
+  /**
+   * True when the segment carried an explicit positive fraction (`;f`).
+   * False when no semicolon was present or the fraction was 0.
+   * @see lib/common/emit.c:488-489
+   */
+  hasFraction: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/emit.c:451 EPS */
+const EPS = 1e-5;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** True when |x| < EPS. @see lib/common/emit.c:452 AEQ0 */
+function aeq0(x: number): boolean {
+  return x < EPS && x > -EPS;
+}
+
+/**
+ * Parse "color;fraction" or "color" into { color, v }.
+ * v === 0  → no semicolon (no explicit fraction).
+ * v > 0    → valid non-negative fraction.
+ * v === -1 → semicolon present but no valid non-negative float.
+ * @see lib/common/emit.c:429 getSegLen
+ */
+function getSegLen(token: string): { color: string; v: number } {
+  const semi = token.indexOf(';');
+  if (semi === -1) return { color: token, v: 0 };
+  const color = token.slice(0, semi);
+  const rest = token.slice(semi + 1);
+  if (rest.length === 0) return { color, v: -1 };
+  const parsed = parseFloat(rest);
+  return !isNaN(parsed) && parsed >= 0 ? { color, v: parsed } : { color, v: -1 };
+}
+
+/**
+ * Clamp one token against `left`, append to `segs`, return updated `left`.
+ * Returns null on a parse error (bad float after semicolon).
+ * @see lib/common/emit.c:476-506
+ */
+function appendSeg(
+  token: string,
+  left: number,
+  segs: ColorSeg[],
+  warnedExceeded: { v: boolean },
+): { left: number; rval: 0 | 3 } | null {
+  const { color, v } = getSegLen(token);
+  if (v < 0) return null;
+
+  let t = v;
+  let rval: 0 | 3 = 0;
+  const del = t - left;
+  if (del > 0) {
+    if (!aeq0(del) && !warnedExceeded.v) {
+      warnedExceeded.v = true;
+      rval = 3;
+    }
+    t = left;
+  }
+  left -= t;
+  segs.push({ color: color.length > 0 ? color : null, t, hasFraction: t > 0 && v > 0 });
+  return { left, rval };
+}
+
+/**
+ * Distribute `left` weight among zero-t segments; if none, add to last.
+ * @see lib/common/emit.c:509-526
+ */
+function distributeLeft(segs: ColorSeg[], left: number): void {
+  if (left <= 0) return;
+  const zeroCount = segs.filter(s => s.t <= 0).length;
+  if (zeroCount > 0) {
+    const delta = left / zeroCount;
+    for (const s of segs) {
+      if (s.t <= 0) s.t = delta;
+    }
+  } else if (segs.length > 0) {
+    segs[segs.length - 1]!.t += left;
+  }
+}
+
+/**
+ * Drop trailing zero-t segments (mirrors C's LIST_DROP_BACK loop).
+ * @see lib/common/emit.c:528-532
+ */
+function trimTrailing(segs: ColorSeg[]): void {
+  while (segs.length > 0 && (segs[segs.length - 1]?.t ?? 0) <= 0) {
+    segs.pop();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse `"c1;f1:c2;f2:…"` into segments.
+ *
+ * Fractions are optional and non-negative; their sum must not exceed 1.
+ * Segments without an explicit fraction share the remaining weight equally;
+ * if none exist the remainder is added to the last segment.
+ *
+ * Return codes (mirror C):
+ *   0 → ok; 1 → silent error; 2 → error with message; 3 → warning (sum > 1).
+ * On rv 1 or 2 the returned segs array is empty.
+ *
+ * @see lib/common/emit.c:470 parseSegs
+ */
+export function parseSegs(
+  colorlist: string,
+): { segs: ColorSeg[]; error: 0 | 1 | 2 | 3 } {
+  const segs: ColorSeg[] = [];
+  let left = 1;
+  let rval: 0 | 3 = 0;
+  let badFloatCount = 0;
+  const warnedExceeded = { v: false };
+
+  for (const token of colorlist.split(':')) {
+    const result = appendSeg(token, left, segs, warnedExceeded);
+    if (result === null) {
+      const errCode: 1 | 2 = badFloatCount === 0 ? 2 : 1;
+      badFloatCount++;
+      return { segs: [], error: errCode };
+    }
+    if (result.rval === 3) rval = 3;
+    left = result.left;
+    if (aeq0(left)) { left = 0; break; }
+  }
+
+  distributeLeft(segs, left);
+  trimTrailing(segs);
+  return { segs, error: rval };
+}

package/src/common/nodeinit.ts

@@ -0,0 +1,339 @@
+// SPDX-License-Identifier: EPL-2.0
+/**
+ * Common node geometry initialisation shared by all layout engines.
+ * Ports common_init_node / gv_nodesize from lib/common/utils.c: binds
+ * the shape, builds the label (text/html/record), and sizes the node
+ * from the label via the poly_init port.
+ *
+ * @see lib/common/utils.c:common_init_node
+ * @see lib/common/utils.c:gv_nodesize
+ */
+
+import type { Graph } from '../model/graph.js';
+import type { Node } from '../model/node.js';
+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 { makeAnyLabel } from './make-label.js';
+import { isHtmlValue, htmlValueContent } from './html-string.js';
+import { NODE_XLABEL } from '../layout/dot/rank.js';
+import { recordInit, recordMakeLabel } from './record.js';
+import {
+  GAP,
+  gvNodesize,
+  polySize,
+  type PolySizeParams,
+  type PolySizeResult,
+} from './poly-sizing.js';
+
+/** Default node half-width in points. C: DEFAULT_NODEWIDTH=0.75in/2 * 72 = 27 */
+export const DEFAULT_NODE_LW = 27;
+/** Default node full-height in points. C: DEFAULT_NODEHEIGHT=0.5in * 72 = 36 */
+export const DEFAULT_NODE_HT = 36;
+
+/** @see lib/common/const.h:DEFAULT_NODEWIDTH / MIN_NODEWIDTH */
+const DEFAULT_NODEWIDTH = 0.75;
+const MIN_NODEWIDTH = 0.01;
+/** @see lib/common/const.h:DEFAULT_NODEHEIGHT / MIN_NODEHEIGHT */
+const DEFAULT_NODEHEIGHT = 0.5;
+const MIN_NODEHEIGHT = 0.02;
+
+/** Points per inch. @see lib/common/geom.h:POINTS_PER_INCH */
+const POINTS_PER_INCH = 72;
+/** Default point size in inches (3.6pt). @see lib/common/shapes.c:42 DEF_POINT */
+const DEF_POINT = 0.05;
+/** Minimum point size in inches. @see lib/common/shapes.c:47 MIN_POINT */
+const MIN_POINT = 0.0003;
+/** Default / minimum node penwidth. @see lib/common/const.h DEFAULT_NODEPENWIDTH */
+const DEFAULT_NODEPENWIDTH = 1;
+const MIN_NODEPENWIDTH = 0;
+
+/** Parse a double attr with default and minimum. @see lib/common/utils.c:late_double */
+export function lateDouble(
+  s: string | undefined,
+  defaultValue: number,
+  minimum: number,
+): number {
+  if (s === undefined || s === '') return defaultValue;
+  const rv = parseFloat(s);
+  if (Number.isNaN(rv)) return defaultValue;
+  return rv < minimum ? minimum : rv;
+}
+
+/** Parse an int attr with default and minimum. @see lib/common/utils.c:late_int */
+export function lateInt(
+  s: string | undefined,
+  defaultValue: number,
+  minimum: number,
+): number {
+  if (s === undefined || s === '') return defaultValue;
+  const rv = parseInt(s, 10);
+  if (Number.isNaN(rv)) return defaultValue;
+  return rv < minimum ? minimum : rv;
+}
+
+/** @see lib/common/utils.c:mapbool */
+function mapbool(s: string | undefined): boolean {
+  if (!s || s.toLowerCase() === 'false' || s.toLowerCase() === 'no') return false;
+  if (s.toLowerCase() === 'true' || s.toLowerCase() === 'yes') return true;
+  const n = parseInt(s, 10);
+  return !Number.isNaN(n) && n !== 0;
+}
+
+/** The text measurer threaded through the GVC context, if any. */
+export function layoutMeasurer(g: Graph): TextMeasurer | undefined {
+  return g.root.info.gvc?.textMeasurer;
+}
+
+/**
+ * Resolve sides/skew/distortion: builtin descriptors win; shape=polygon
+ * (sides == 0) reads the attrs. @see lib/common/shapes.c:poly_init
+ */
+function resolvePolyGeometry(
+  n: Node,
+  g: Graph,
+  poly: PolygonT,
+): { sides: number; skew: number; distortion: number } {
+  if (poly.sides !== 0) {
+    return { sides: poly.sides, skew: poly.skew, distortion: poly.distortion };
+  }
+  return {
+    skew: lateDouble(nodeAttr(n, g, 'skew'), 0.0, -100.0),
+    sides: lateInt(nodeAttr(n, g, 'sides'), 4, 0),
+    distortion: lateDouble(nodeAttr(n, g, 'distortion'), 0.0, -100.0),
+  };
+}
+
+/** User size in points: max of set width/height attrs, 0 when unset. @see shapes.c:userSize */
+function userSizePts(n: Node, g: Graph): number {
+  const uw = lateDouble(nodeAttr(n, g, 'width'), 0.0, MIN_NODEWIDTH);
+  const uh = lateDouble(nodeAttr(n, g, 'height'), 0.0, MIN_NODEHEIGHT);
+  return 72 * Math.max(uw, uh);
+}
+
+/** Size-related plain attrs read by poly_init. */
+function sizeAttrs(
+  n: Node,
+  g: Graph,
+): Pick<PolySizeParams, 'widthIn' | 'heightIn' | 'userSizePts' | 'margin' | 'fixedsize' | 'labelloc' | 'quantumIn'> {
+  return {
+    widthIn: lateDouble(nodeAttr(n, g, 'width'), DEFAULT_NODEWIDTH, MIN_NODEWIDTH),
+    heightIn: lateDouble(nodeAttr(n, g, 'height'), DEFAULT_NODEHEIGHT, MIN_NODEHEIGHT),
+    userSizePts: userSizePts(n, g),
+    margin: nodeAttr(n, g, 'margin'),
+    fixedsize: nodeAttr(n, g, 'fixedsize') ?? 'false',
+    labelloc: nodeAttr(n, g, 'labelloc'),
+    quantumIn: lateDouble(g.root.attrs.get('quantum'), 0.0, 0.0),
+  };
+}
+
+/**
+ * Resolve poly_init's sizing inputs from node attrs and the bound
+ * polygon descriptor.
+ * @see lib/common/shapes.c:poly_init (attribute resolution)
+ */
+export function polySizeParamsFromNode(
+  n: Node,
+  g: Graph,
+  shape: ShapeDesc & { polygon: PolygonT },
+  labelDimen: { x: number; y: number },
+  flip: boolean,
+): PolySizeParams {
+  const poly = shape.polygon;
+  return {
+    labelDimen,
+    ...resolvePolyGeometry(n, g, poly),
+    ...sizeAttrs(n, g),
+    peripheries: lateInt(nodeAttr(n, g, 'peripheries'), poly.peripheries, 0),
+    orientation: poly.orientation + lateDouble(nodeAttr(n, g, 'orientation'), 0.0, -360.0),
+    // @see lib/common/shapes.c:poly_init — late_double(n, N_penwidth, 1.0, 0.0)
+    penwidth: lateDouble(nodeAttr(n, g, 'penwidth'), 1.0, 0.0),
+    regular: poly.regular || mapbool(nodeAttr(n, g, 'regular')),
+    isPlain: shape.name === 'plain',
+    optionShape: poly.option.shape, // size_gen discriminant (STAR/CYLINDER)
+    nojustify: mapbool(nodeAttr(n, g, 'nojustify')), // shapes.c:2133
+    flip,
+  };
+}
+
+/**
+ * Create ND_xlabel when the xlabel attr is non-empty and set NODE_XLABEL.
+ * @see lib/common/utils.c:443-447
+ * @see lib/common/utils.c:447 — GD_has_labels scoped to agraphof(n) root
+ */
+function initNodeXLabel(n: Node, g: Graph, measurer: TextMeasurer): void {
+  const str = nodeAttr(n, g, 'xlabel');
+  if (!str || str.length === 0) return;
+  const font = readFontAttrs(n, g);
+  const isHtml = isHtmlValue(str);
+  const content = isHtml ? htmlValueContent(str) : str;
+  // utils.c:444 — make_label(n, str, aghtmlstr(str), false, ...)
+  n.info.xlabel = makeAnyLabel(content, isHtml, font, measurer, n);
+  g.root.info.has_labels = (g.root.info.has_labels ?? 0) | NODE_XLABEL;
+}
+
+/**
+ * Point diameter in inches per point_init: w = min(width, height); if
+ * neither attr is user-set use DEF_POINT, else clamp positive widths to
+ * MIN_POINT. The (suppressed) label never drives the size.
+ * @see lib/common/shapes.c:point_init (width/height block)
+ */
+function pointWidthInches(n: Node, g: Graph): number {
+  const w = lateDouble(nodeAttr(n, g, 'width'), Number.MAX_VALUE, MIN_NODEWIDTH);
+  const h = lateDouble(nodeAttr(n, g, 'height'), Number.MAX_VALUE, MIN_NODEHEIGHT);
+  const m = Math.min(w, h);
+  if (m === Number.MAX_VALUE) return DEF_POINT; // neither width nor height set
+  return m > 0.0 ? Math.max(m, MIN_POINT) : m;
+}
+
+/**
+ * point_init's size math: the dot diameter `sz0` grown by GAP per extra
+ * periphery, plus the outline ring at half the penwidth each side.
+ * @see lib/common/shapes.c:point_init (periphery/outline blocks)
+ */
+function pointSizeResult(
+  sz0: number, peripheries: number, penwidth: number,
+): Omit<PolySizeResult, 'space' | 'valign'> {
+  const sz = peripheries > 1 ? sz0 + 2 * GAP * (peripheries - 1) : sz0;
+  const szOutline = peripheries >= 1 && penwidth > 0 ? sz + penwidth : sz;
+  return {
+    ...gvNodesize(sz, sz, false),
+    outlineW: szOutline, outlineH: szOutline, baseW: sz0, baseH: sz0,
+  };
+}
+
+/**
+ * Size a `shape=point` node per point_init: a filled dot, DEF_POINT (or
+ * the min set width/height) wide, bypassing label-driven sizing. Reuses
+ * the ellipse vertex/periphery path (AD-5): the resolved sides=2 polygon
+ * renders via the existing `sides<=2` ellipse branch.
+ * @see lib/common/shapes.c:point_init
+ */
+function initPointSize(n: Node, g: Graph, shape: ShapeDesc & { polygon: PolygonT }): void {
+  const flip = g.root.info.flip === true;
+  const peripheries = lateInt(nodeAttr(n, g, 'peripheries'), shape.polygon.peripheries, 0);
+  const penwidth = lateDouble(nodeAttr(n, g, 'penwidth'), DEFAULT_NODEPENWIDTH, MIN_NODEPENWIDTH);
+  const sz0 = pointWidthInches(n, g) * POINTS_PER_INCH;
+  storeNodeSize(n, pointSizeResult(sz0, peripheries, penwidth), flip);
+  assignShapeInfo(n, { ...shape.polygon, peripheries, sides: 2, penwidth, vertices: null });
+}
+
+/**
+ * Build the label and size the node from it, mirroring
+ * common_init_node + the shape initfn. Returns false when the shape
+ * has no polygon descriptor to size against.
+ * @see lib/common/utils.c:common_init_node
+ */
+function initNodeFromLabel(n: Node, g: Graph, measurer: TextMeasurer): boolean {
+  const shape = bindShape(nodeAttr(n, g, 'shape') ?? 'ellipse', nodeAttr(n, g, 'shapefile'));
+  n.info.shape = shape;
+  if (shape.kind === ShapeKind.SH_RECORD) {
+    // C runs the SAME three steps for every shape: make_label (with the
+    // is_record flag), then ND_xlabel, then the shape's initfn. SH_RECORD
+    // only selects make_label's is_record flag and initfn=record_init — it is
+    // NOT a reason to skip the xlabel (utils.c:441/443/453).
+    recordMakeLabel(n, g, measurer);
+    initNodeXLabel(n, g, measurer);
+    recordInit(n, g, measurer); // initfn: sets lw/rw/ht from the field tree
+    return true;
+  }
+  buildNodeLabel(n, g, measurer);
+  initNodeXLabel(n, g, measurer);
+  const poly = shape.polygon;
+  if (poly === null) return false;
+  if (shape.kind === ShapeKind.SH_POINT) {
+    // point_init overrides sizing independent of the label (AD-2).
+    initPointSize(n, g, { ...shape, polygon: poly });
+    return true;
+  }
+  const label = n.info.label as TextlabelT;
+  const flip = g.root.info.flip === true;
+  const params = polySizeParamsFromNode(n, g, { ...shape, polygon: poly }, label.dimen, flip);
+  // Unflipped size first so width/height (inches) match C's ND_width/ND_height.
+  const sz = polySize({ ...params, flip: false });
+  // Install the label's justification borders + valign, as C's poly_init mutates
+  // ND_label(n)->space / ->valign in place — consumed by emit_label/renderLabel
+  // for labelloc top/bottom and left/right justification.
+  label.space = sz.space;
+  label.valign = sz.valign.charCodeAt(0);
+  storeNodeSize(n, sz, flip);
+  // C poly_init installs the ATTR-RESOLVED polygon into ND_shape_info
+  // (sides/orientation/skew/distortion/peripheries/regular); edge
+  // clipping and rendering read it.
+  assignShapeInfo(n, effectivePolygon(poly, params));
+  return true;
+}
+
+/** The attr-resolved polygon poly_init stores. @see shapes.c:poly_init (poly->... assignments) */
+function effectivePolygon(poly: PolygonT, p: PolySizeParams): PolygonT {
+  let sides = p.sides;
+  // ellipses with distortion/skew become 120-gons
+  if (sides <= 2 && (p.distortion !== 0 || p.skew !== 0)) sides = 120;
+  return {
+    ...poly,
+    regular: p.regular,
+    peripheries: p.peripheries,
+    sides,
+    orientation: p.orientation,
+    distortion: p.distortion,
+    skew: p.skew,
+    penwidth: p.penwidth ?? 1,
+  };
+}
+
+/** Write polySize results onto the node (gv_nodesize flip applied last). */
+function storeNodeSize(
+  n: Node, unflipped: Omit<PolySizeResult, 'space' | 'valign'>, flip: boolean,
+): void {
+  const widthPts = unflipped.lw + unflipped.rw;
+  n.info.width = widthPts / 72;
+  n.info.height = unflipped.ht / 72;
+  n.info.outline_width = unflipped.outlineW / 72;
+  n.info.outline_height = unflipped.outlineH / 72;
+  n.info.base_width = unflipped.baseW / 72;
+  n.info.base_height = unflipped.baseH / 72;
+  // C gv_nodesize derives lw/rw/ht from INCH2PS(ND_width/ND_height), i.e. it
+  // round-trips the points size through the PS2INCH inch value it just stored
+  // (shapes.c:2372 ND_width=PS2INCH(bb.x); utils.c:1543 w=INCH2PS(ND_width)).
+  // Passing the raw poly points here skips that round-trip, so ND_xsize
+  // (lw+rw) would differ from INCH2PS(ND_width) by 1 ULP — which in osage
+  // desyncs the packing-box centre from addNodeObj's coord-sz/2 and flips a
+  // floor() in objplpmks. Round-trip to match C exactly.
+  const size = gvNodesize(
+    n.info.width * POINTS_PER_INCH, n.info.height * POINTS_PER_INCH, flip,
+  );
+  n.info.lw = size.lw;
+  n.info.rw = size.rw;
+  n.info.ht = size.ht;
+}
+
+/** Pre-T1 fallback sizing from width/height attrs only (no measurer). */
+function initNodeDefaults(n: Node, g: Graph): void {
+  const widthIn = lateDouble(nodeAttr(n, g, 'width'), DEFAULT_NODEWIDTH, MIN_NODEWIDTH);
+  const heightIn = lateDouble(nodeAttr(n, g, 'height'), DEFAULT_NODEHEIGHT, MIN_NODEHEIGHT);
+  const flip = g.root.info.flip === true;
+  const w = flip ? heightIn : widthIn;
+  const h = flip ? widthIn : heightIn;
+  if (!n.info.lw) n.info.lw = Math.max((w * 72) / 2, DEFAULT_NODE_LW);
+  if (!n.info.rw) n.info.rw = Math.max((w * 72) / 2, DEFAULT_NODE_LW);
+  if (!n.info.ht) n.info.ht = Math.max(h * 72, DEFAULT_NODE_HT);
+}
+
+/**
+ * Initialise per-node geometry: shape-aware, label-driven sizing when a
+ * text measurer is available; width/height attr defaults otherwise.
+ * @see lib/common/utils.c:common_init_node
+ * @see lib/common/utils.c:gv_nodesize
+ */
+export function commonInitNode(n: Node, g: Graph): void {
+  const measurer = layoutMeasurer(g);
+  if (measurer !== undefined && initNodeFromLabel(n, g, measurer)) return;
+  initNodeDefaults(n, g);
+}
+
+/** Call commonInitNode for every node in the graph. */
+export function commonInitNodeEdge(g: Graph): void {
+  for (const n of g.nodes.values()) commonInitNode(n, g);
+}