@knowvah/dot-engine 1.1.1 → 1.2.1

package/src/render/dot/attrs.ts

@@ -0,0 +1,437 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Attribute helpers for the `-Tdot` writer — the `attach_attrs_and_arrows`
+ * side of output.c, plus the value-record and dict-default rules
+ * write_nondefault_attrs / write_dict compare against.
+ *
+ * @see lib/common/output.c:254 attach_attrs_and_arrows
+ * @see lib/cgraph/write.c:471 write_nondefault_attrs
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import { IGNORED } from '../../layout/dot/rank.js';
+import { agstrcanon } from '../map.js';
+import { POINTS_PER_INCH } from '../../model/geom.js';
+import type { TextlabelT, FieldT } from '../../common/types.js';
+import { agcanonEscape, gfmt2, gfmt5, lpStr } from './xdot-ops.js';
+
+/**
+ * C's `attach_attrs` edge loop skips IGNORED edges and edges with no spline
+ * (`ED_spl(e) == NULL`) via `continue`, so such an edge is attached NEITHER
+ * `pos` NOR any of `lp`/`xlp`/`head_lp`/`tail_lp` — even when it carries a
+ * label. All five attributes therefore share this one gate.
+ * @see lib/common/output.c:349-353
+ */
+export function edgeAttrsAttached(e: Edge): boolean {
+  return e.info.edge_type !== IGNORED && e.info.spl != null;
+}
+
+/**
+ * Append the leaf-field rectangles of a record node, mirroring the recursion in
+ * `set_record_rects`: a field with sub-fields contributes nothing itself, while
+ * a LEAF field (`n_flds == 0`) contributes its box translated by the node centre
+ * as `llx,lly,urx,ury` at `%.5g`. C emits each field followed by a space and
+ * then pops the trailing one — joining with a single space is equivalent.
+ * @see lib/common/output.c:215 set_record_rects
+ */
+export function appendRecordRects(n: Node, f: FieldT, out: string[]): void {
+  const c = n.info.coord;
+  if (f.n_flds === 0) {
+    out.push(
+      gfmt5(f.b.ll.x + c.x) + ',' + gfmt5(f.b.ll.y + c.y) + ',' +
+      gfmt5(f.b.ur.x + c.x) + ',' + gfmt5(f.b.ur.y + c.y),
+    );
+  }
+  for (let i = 0; i < f.n_flds; i++) appendRecordRects(n, f.fld![i], out);
+}
+
+/**
+ * Echo an attribute that `attach_attrs_and_arrows` did NOT overwrite.
+ *
+ * Every computed attribute is `agset` behind a gate (`rects` only for a
+ * `record` shape; an edge's `lp` only for a routed edge that HAS a label;
+ * a graph's `lp` only when `GD_label(g)` exists...). When the gate FAILS, C
+ * simply does not write — so the slot keeps whatever the INPUT file parsed
+ * into it, and `agwrite` (which serializes the whole attribute table, not
+ * just the fields layout computed) prints that stale value verbatim. This is
+ * highly visible under patchwork, which forces every shape to `box` and routes
+ * no edges: on a re-fed dot output (most of the corpus) native echoes back the
+ * `rects` / `lp` a *previous* dot run wrote, in that run's coordinate space.
+ *
+ * cgraph interns attribute strings, so a value equal to the declared (empty)
+ * default is the SAME pointer as the default and write.c's
+ * `data->str[sym->id] != sym->defval` test drops it — hence an empty value is
+ * never printed.
+ * @see lib/cgraph/write.c:427 write_nondefault_attrs · lib/common/output.c:270
+ */
+/** Names the serializer computes for a node; never echoed from input. */
+export const COMPUTED_NODE_ATTRS = new Set(['pos', 'width', 'height', 'xlp', 'rects', '_draw_', '_ldraw_']);
+
+/** Names the serializer computes for an edge. `tailport`/`headport` are excluded
+ *  too: write_nondefault_attrs skips those symbols because they are written as
+ *  `:port` syntax on the endpoints instead. @see lib/cgraph/write.c:487-492 */
+export const COMPUTED_EDGE_ATTRS = new Set([
+  'pos', 'lp', 'xlp', 'head_lp', 'tail_lp', 'tailport', 'headport',
+  '_draw_', '_ldraw_', '_hdraw_', '_tdraw_', '_hldraw_', '_tldraw_',
+]);
+
+/** dot's synthesized AGNODE `label` default. @see lib/common/const.h NODENAME_ESC */
+export const NODENAME_ESC = '\\N';
+
+/** Effective edge defaults at `scope`, inner overriding outer — mirrors the
+ *  builder's snapshotEdgeDefaults walk (builder.ts:294). Edges have no stored
+ *  snapshot: the builder copies inherited defaults straight into `edge.attrs`,
+ *  so the only way to tell a defaulted value from an explicit one is to compare
+ *  against this walk. That merge also means `edge.attrs` already IS the cgraph
+ *  value record `objInputParts` expects — the node side has to build one
+ *  (`nodeRecord`) because node defaults are kept in a separate snapshot. */
+export function effectiveEdgeDefaults(scope: Graph): Map<string, string> {
+  const eff = new Map<string, string>();
+  for (let g: Graph | null = scope; g !== null; g = g.parent) {
+    for (const [k, v] of g.edgeDefaults) if (!eff.has(k)) eff.set(k, v);
+  }
+  return eff;
+}
+
+/**
+ * Effective node defaults at `scope`, inner overriding outer — the dict
+ * write_node compares each node against (`d`, threaded from write_body,
+ * write.c:537-545). This is the scope the node is WRITTEN in, which is not
+ * necessarily where it was created.
+ *
+ * Includes dot's synthesized `label` default: `graph_init` installs
+ * NODENAME_ESC on the root when the input declares none (input.c:737-739), and
+ * it is part of the dict C compares against. `nodeRecord` seeds the same value
+ * under the same condition so the two cancel — omitting it from either side
+ * would print `label="\N"` (or `label=""`) on every node in the corpus.
+ * @see lib/cgraph/write.c:537-545 write_node · lib/common/input.c:737-739
+ */
+export function effectiveNodeDefaults(scope: Graph): Map<string, string> {
+  const eff = new Map<string, string>();
+  for (let g: Graph | null = scope; g !== null; g = g.parent) {
+    for (const [k, v] of g.nodeDefaults) if (!eff.has(k)) eff.set(k, v);
+  }
+  if (!eff.has('label')) eff.set('label', NODENAME_ESC);
+  return eff;
+}
+
+/**
+ * One node's cgraph value RECORD: the node-dict defaults in effect where the
+ * node was CREATED, overridden by its own explicit attributes.
+ *
+ * `addattr` seeds a node's slot from the default at declaration time and an
+ * explicit `n [k=v]` overwrites it; neither is disturbed by a LATER
+ * `node [k=…]` in the same scope, which only moves the dict symbol. That gap is
+ * the whole mechanism: `{node[shape=house]; A; node[shape=invhouse]; B}` leaves
+ * A's record at `house` against a dict default of `invhouse`, so C prints
+ * `shape=house` on A and nothing on B.
+ * @see lib/cgraph/attr.c:210 addattr · lib/cgraph/write.c:485
+ */
+export function nodeRecord(n: Node): Map<string, string> {
+  const rec = new Map<string, string>(n.nodeDefaultsSnapshot ?? []);
+  if (!rec.has('label')) rec.set('label', NODENAME_ESC);
+  for (const [k, v] of n.attrs) rec.set(k, v);
+  return rec;
+}
+
+/**
+ * One object's attribute block: every name whose value RECORD differs from the
+ * writing scope's dict default. A name in the dict but not the record compares
+ * as empty and prints as `k=""` — `digraph G { a; node[color=red]; b; }` emits
+ * `a [color=""]`, which a record-only walk structurally cannot produce.
+ * @see lib/cgraph/write.c:471 write_nondefault_attrs
+ */
+export function objInputParts(
+  record: Map<string, string>,
+  defaults: Map<string, string>,
+  computed: Set<string>,
+): string[] {
+  const parts: string[] = [];
+  for (const k of new Set([...record.keys(), ...defaults.keys()])) {
+    if (computed.has(k)) continue;
+    const v = record.get(k) ?? '';
+    if (v === (defaults.get(k) ?? '')) continue;
+    parts.push(k + '=' + agstrcanon(v));
+  }
+  return parts;
+}
+
+/**
+ * A COMPUTED node/edge attribute, dropped when its value equals the applicable
+ * dict default.
+ *
+ * `safe_dcl` declares each computed name with an empty default only when the
+ * symbol does not already exist — an input file that says `node [width=0.5]`
+ * leaves `sym->defval` at `0.5`. cgraph interns strings, so `agxset`ing a
+ * computed `0.5` stores the SAME refstr as the default and
+ * write_nondefault_attrs' `data->str[sym->id] != sym->defval` test drops it.
+ * tests/graphs/arrows.gv is the clean case: every node emits `height=0.5`
+ * (no declared default) but none emits `width`.
+ *
+ * `formatted` is passed in rather than derived so each call site keeps its own
+ * quoting; `raw` is the unquoted text that C would have interned.
+ * @see lib/common/utils.c:1065 safe_dcl · lib/cgraph/write.c:485
+ */
+export function computedPart(
+  key: string,
+  raw: string,
+  defaults: Map<string, string> | undefined,
+): string[] {
+  if (defaults !== undefined && defaults.get(key) === raw) return [];
+  // C agsets the raw computed text (output.c) and lets agwrite canonicalize it
+  // on the way out, so the quoting DECISION and the 128-byte line breaking both
+  // belong here rather than at the call site: `lheight=0.23` prints bare while
+  // a long `pos` is split across lines with a trailing backslash.
+  // @see lib/cgraph/write.c:481 write_nondefault_attrs -> write_canonstr
+  return [key + '=' + agstrcanon(raw)];
+}
+
+/** Attribute names the serializer computes itself; input values are echoed by
+ *  `graphInputParts`, so these must not be echoed twice. */
+export const COMPUTED_GRAPH_ATTRS = new Set([
+  '_draw_', '_ldraw_', 'bb', 'lp', 'lwidth', 'lheight',
+]);
+
+/** `COMPUTED_GRAPH_ATTRS` for a renderer that emits draw ops. Only
+ *  `xdot_begin_graph` agsets `xdotversion` (gvrender_core_dot.c:341); plain
+ *  `-Tdot` never computes it, so an input `xdotversion=1.7` stays an ordinary
+ *  attribute there and write.c echoes it like any other. */
+const COMPUTED_GRAPH_ATTRS_XDOT = new Set([...COMPUTED_GRAPH_ATTRS, 'xdotversion']);
+
+/** The computed-attr set in force for this renderer. */
+function computedGraphAttrs(emitDraws: boolean): Set<string> {
+  return emitDraws ? COMPUTED_GRAPH_ATTRS_XDOT : COMPUTED_GRAPH_ATTRS;
+}
+
+/** Walk to the root graph (cgraph `agroot`). */
+export function rootOf(g: Graph): Graph {
+  let cur: Graph = g;
+  while (cur.parent !== null) cur = cur.parent;
+  return cur;
+}
+
+/**
+ * A scope's own graph-attribute dict entries — the INPUT attributes, echoed by
+ * write_dict because in cgraph a graph's attributes ARE its dict defaults.
+ *
+ * For a non-root scope the test is PROVENANCE, not value. `setattr` gives a
+ * subgraph its own dict symbol for every attribute the input declares in that
+ * scope, and write_dict prints each local symbol whose value is non-empty —
+ * there is no comparison against the inherited value, so re-declaring an
+ * attribute to the value it already inherited still prints. Oracle-pinned:
+ * `digraph G { foo="x"; { foo="x"; a; b } }` emits `foo=x` on the subgraph.
+ *
+ * The only entries in `attrs` that are NOT local declarations are the ones the
+ * builder seeded from the snapshot so cluster-label inheritance survives the
+ * layout's cluster rebuilds; those carry no dict symbol in C and are recorded in
+ * `seededAttrs`. (A value-equality test stood in for this before the marker
+ * existed, and wrongly swallowed genuine re-declarations.)
+ *
+ * Also reproduces C's EAGER-propagation artifact. `agattr` creating a NEW global
+ * graph attribute runs `agapply(root, addattr, rsym, true)`, installing the
+ * symbol — with its pre-declaration (empty) default — on every subgraph that
+ * ALREADY EXISTS. So a subgraph opened before the declaration carries a local
+ * empty value and agwrite prints e.g. `rankdir=""`, while a sibling opened after
+ * it inherits and prints nothing. `graphDefaultsSnapshot` records exactly which
+ * defaults were in effect when the scope opened, so "declared at root after this
+ * scope opened" is `root.attrs.has(k) && !snapshot.has(k)`.
+ * @see lib/cgraph/attr.c:287 (agapply/addattr) · lib/cgraph/write.c:262
+ */
+export function graphInputParts(g: Graph, top: boolean, emitDraws: boolean): string[] {
+  const computed = computedGraphAttrs(emitDraws);
+  const parts: string[] = [];
+  const snap = g.graphDefaultsSnapshot;
+  const seeded = g.seededAttrs;
+  for (const [k, v] of g.attrs) {
+    if (computed.has(k)) continue;
+    if (!top && seeded !== undefined && seeded.has(k)) continue;
+    if (writeDictSkips(v, snap?.get(k))) continue;
+    parts.push(k + '=' + agstrcanon(v));
+  }
+  if (!top && snap !== undefined) parts.push(...eagerEmptyParts(g, snap, computed));
+  return parts;
+}
+
+/**
+ * C's EAGER-propagation artifact. Setting a graph attribute in scope S runs
+ * `unviewsubgraphsattr(S, name)`, which walks `agfstsubg(S)` and gives every
+ * subgraph with no local definition its own symbol holding the value it had at
+ * that moment — empty, when the attribute is only now being declared. agwrite
+ * then prints that local `rankdir=""`, while a sibling opened afterwards simply
+ * inherits and prints nothing.
+ *
+ * Two things narrow this. The walk is over DIRECT subgraphs and is NOT
+ * recursive, so the trigger is the immediate PARENT declaring the key, not any
+ * ancestor: in `A { B { C {…} } graph[label=x] }` only B prints `label=""`,
+ * never C. And setattr only reaches `unviewsubgraphsattr` on the branch where
+ * the key had no symbol yet, so the parent's declaration must be the FIRST
+ * anywhere (`firstGraphDecl`) — once a sibling scope has declared the key, the
+ * same statement takes the "new local definition" branch and seeds nothing.
+ * @see lib/cgraph/attr.c:232 unviewsubgraphsattr · :257 setattr (branch split)
+ */
+function eagerEmptyParts(g: Graph, snap: Map<string, string>, computed: Set<string>): string[] {
+  const parts: string[] = [];
+  const p = g.parent;
+  if (p === null) return parts;
+  // The ROOT is special: a global declaration made anywhere inserts its symbol
+  // into the root's OWN dict, so by the time the root declares the key setattr
+  // always finds a local symbol and takes the unview branch. A non-root scope
+  // only holds a local symbol for a key it declared first.
+  const keys = p.parent === null ? p.attrs.keys() : (p.firstGraphDecl ?? []);
+  for (const k of keys) {
+    if (computed.has(k)) continue;
+    if (snap.has(k) || g.attrs.has(k)) continue;
+    parts.push(k + '=' + agstrcanon(''));
+  }
+  return parts;
+}
+
+/**
+ * `name=value` parts for one attribute-default map, values canonicalized by the
+ * `_agstrcanon` port (conditional quoting — `rankdir=LR` bare, `bb="0,0,1,1"`
+ * quoted), matching write_canonstr. @see lib/cgraph/write.c:write_canonstr
+ */
+export function dictParts(defaults: Map<string, string>): string[] {
+  const parts: string[] = [];
+  for (const [k, v] of defaults) parts.push(k + '=' + agstrcanon(v));
+  return parts;
+}
+
+/**
+ * Node-dict parts for a scope. At the root, dot's `graph_init` installs an
+ * AGNODE `label` default of NODENAME_ESC (`\N`) when absent — the port models
+ * attributes as per-object Maps and reproduces that default at each use-site
+ * (see the N_label note in common/graph-init.ts), and the serializer is such a
+ * use-site. An explicit root-level `node [label=...]` wins over the synthesized
+ * default. @see lib/common/input.c:737-739 (N_label)
+ */
+export function nodeDictParts(g: Graph, top: boolean): string[] {
+  const defs = new Map(g.nodeDefaults);
+  if (top && !defs.has('label')) defs.set('label', NODENAME_ESC);
+  return dictParts(defs);
+}
+
+export function echoAttr(attrs: Map<string, string>, key: string): string[] {
+  const v = attrs.get(key);
+  if (v === undefined || v.length === 0) return [];
+  return [key + '="' + agcanonEscape(v) + '"'];
+}
+
+/**
+ * write_dict's conditional empty-value skip, as OBSERVED against the oracle.
+ *
+ * A non-empty local value always prints. An empty one is dropped only when the
+ * INHERITED value is present and empty too; an inherited value that is absent
+ * or non-empty leaves the empty local value printed, and so does the root,
+ * which inherits nothing. Pinned with `digraph G { [foo=<i>;] { foo=""; … } }`:
+ * inherited absent PRINTS, inherited `"x"` PRINTS, inherited `""` SKIPS, and
+ * the root's own `foo=""` PRINTS in every one of those.
+ *
+ * Neither half of the C's guard can be read literally. `Agsym_t.print`
+ * (cgraph.h:644) is assigned nowhere in the tree, so porting
+ * `EMPTY(psym->defval) && psym->print` verbatim makes the parent-empty skip
+ * unreachable; and the `view == NULL` skip would drop the root's `foo=""`,
+ * which native prints. The observed rule is authoritative here.
+ * @see lib/cgraph/write.c:271-278 write_dict
+ */
+export function writeDictSkips(v: string, inherited: string | undefined): boolean {
+  return v.length === 0 && inherited === '';
+}
+
+/**
+ * `echoAttr` for a GRAPH attribute the layout did not overwrite — same as
+ * echoAttr except an EMPTY value can still be emitted, per `writeDictSkips`.
+ * So a re-fed dot output whose `{rank=same}` block carries `bb=""`/`lp=""`
+ * under a boxed, labelled cluster echoes both back verbatim
+ * (tests/share/KW91.gv).
+ */
+export function echoGraphAttr(g: Graph, key: string): string[] {
+  const v = g.attrs.get(key);
+  if (v === undefined) return [];
+  if (writeDictSkips(v, g.graphDefaultsSnapshot?.get(key))) return [];
+  return [key + '="' + agcanonEscape(v) + '"'];
+}
+
+/**
+ * The `lp`/`lwidth`/`lheight` triple for a graph or cluster, in C's order.
+ * `rec_attach_bb` attaches them to the root graph AND recursively to every
+ * cluster, but ONLY when the graph carries a label with non-empty text
+ * (`GD_label(g) && GD_label(g)->text[0]`) — an absent or empty-text label emits
+ * none of the three. `lp` is the label centre in points (`%.5g`); `lwidth` and
+ * `lheight` are the label's `dimen` converted to inches and written `%.2f`.
+ * When the gate fails, the input's own values survive and are echoed: patchwork
+ * and osage never build a cluster label object, so a re-fed dot file's cluster
+ * `lp` comes straight back out.
+ * @see lib/common/output.c:239-248 rec_attach_bb
+ */
+export function graphLabelAttrs(g: Graph): string[] {
+  const label = g.info.label as TextlabelT | undefined;
+  if (!label || label.text.length === 0) {
+    return [
+      ...echoGraphAttr(g, 'lp'),
+      ...echoGraphAttr(g, 'lwidth'),
+      ...echoGraphAttr(g, 'lheight'),
+    ];
+  }
+  return [
+    'lp="' + lpStr(label.pos) + '"',
+    'lwidth=' + gfmt2(label.dimen.x / POINTS_PER_INCH),
+    'lheight=' + gfmt2(label.dimen.y / POINTS_PER_INCH),
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// DOT attribute helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Format edge spline points for the DOT `pos` attribute. Per bezier: the start
+ * endpoint `s,sp` when `sflag` set, then the end endpoint `e,ep` when `eflag`
+ * set, then `bez.size` control points — all at `%.5g`, exactly as native's
+ * spline serialization. Beziers are separated by `;`, points within one by a
+ * space. @see lib/common/output.c:353-372
+ */
+export function formatEdgePos(e: Edge): string {
+  const raw = edgePosRaw(e);
+  return raw === null ? '' : 'pos="' + raw + '"';
+}
+
+/** `formatEdgePos`'s value without the `pos="…"` wrapper — the text C interns
+ *  and compares against the symbol default. `null` when no `pos` is attached. */
+export function edgePosRaw(e: Edge): string | null {
+  const spl = e.info.spl;
+  if (!spl || spl.list.length === 0) return null;
+  // Native's pos loop skips IGNORED edges (output.c:350) — concentrate merges
+  // an edge into its opposite and marks the absorbed one IGNORED; it is still
+  // drawn (has _draw_) but carries no `pos`. @see lib/common/output.c:349-353
+  if (e.info.edge_type === IGNORED) return null;
+  // Built imperatively rather than by join() because C's separators are not
+  // uniform: beziers are separated by ';' with no space, while the `s,`/`e,`
+  // endpoints each carry a trailing space from their own format string.
+  let out = '';
+  for (let i = 0; i < spl.size; i++) {
+    const bez = spl.list[i];
+    if (i > 0) out += ';';
+    if (bez.sflag) out += 's,' + gfmt5(bez.sp.x) + ',' + gfmt5(bez.sp.y) + ' ';
+    if (bez.eflag) out += 'e,' + gfmt5(bez.ep.x) + ',' + gfmt5(bez.ep.y) + ' ';
+    for (let j = 0; j < bez.size; j++) {
+      if (j > 0) out += ' ';
+      const p = bez.list[j];
+      out += gfmt5(p.x) + ',' + gfmt5(p.y);
+    }
+  }
+  return out;
+}
+
+/** Return the edge connector token. */
+export function edgeConnector(directed: boolean): string {
+  return directed ? '->' : '--';
+}
+
+/** Return true if the graph is directed or strict-directed. */
+export function isDirected(g: Graph): boolean {
+  return g.kind === 'directed' || g.kind === 'strict-directed';
+}

package/src/render/dot/edge-draw.ts

@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Edge spline + arrow draw-op emission — emit.c's multicolor / tapered / ortho
+ * branches, split out of dot.ts for file size. Same abstract-base approach as
+ * agwrite.ts: every body moves UNCHANGED and reaches the renderer's emit state
+ * (`penwidth`, `styleOp`, `penOp`) through inheritance rather than injection,
+ * so each branch stays diffable against the C.
+ *
+ * @see lib/common/emit.c:2389 multicolor · :2422 tapered · :2583 ortho
+ */
+
+import type { Edge } from '../../model/edge.js';
+import type { Point } from '../../model/geom.js';
+import { isDirected } from './attrs.js';
+import type { Bezier } from '../../model/geom.js';
+import type { ArrowDrawOp } from '../../common/arrows-types.js';
+import type { GVColor } from '../../common/color.js';
+import type { RenderJob } from '../../gvc/job.js';
+import { EmitState } from '../../gvc/job.js';
+import { resolveRenderColor } from '../color-resolve.js';
+import { taper, taperfun } from '../../common/taper.js';
+import { orthoRoundedRadius } from '../svg-helpers.js';
+import { orthoRoundedPolylines } from '../svg-edge-ortho-radius.js';
+import { parseSegs } from '../../common/multicolor.js';
+import { splitSplineByColor } from '../svg-edge-split.js';
+import { buildOffsetLists, advanceTmpList } from '../../common/edge-offset.js';
+import { xdotFillColor, xdotNum, xdotPenColor, xdotPoint, xdotPoints, xdotStrOp, trimFixed3 } from './xdot-ops.js';
+import { DotWriterBase } from './agwrite.js';
+
+/** Pen colour when a colour-list entry is empty. @see lib/common/emit.c:2485 */
+const DEFAULT_COLOR = 'black';
+
+/**
+ * One arrow primitive as an xdot op. Lifted out of emitArrows' loop unchanged —
+ * the four cases and their `filled` variants are exactly arrow_gen's.
+ * @see lib/common/arrows.c arrow_gen
+ */
+function emitArrowOp(buf: string[], op: ArrowDrawOp, pen: GVColor): void {
+  switch (op.kind) {
+    case 'polygon':
+      if (op.filled) buf.push(xdotFillColor(pen));
+      buf.push(xdotPoints(op.filled ? 'P' : 'p', op.points));
+      break;
+    case 'ellipse':
+      if (op.filled) buf.push(xdotFillColor(pen));
+      buf.push(
+        (op.filled ? 'E ' : 'e ') + xdotPoint(op.center) +
+          xdotNum(op.rx) + ' ' + xdotNum(op.ry) + ' ',
+      );
+      break;
+    case 'polyline':
+      buf.push(xdotPoints('L', op.points));
+      break;
+    case 'bezier':
+      buf.push(xdotPoints('B', op.points));
+      break;
+  }
+}
+
+/** emit.c's edge-drawing half, between the serializer base and the renderer. */
+export abstract class EdgeDrawBase extends DotWriterBase {
+  /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
+  protected penwidth: number[] = new Array(12).fill(1);
+  protected abstract styleOp(job: RenderJob): string;
+  protected abstract penOp(job: RenderJob): string;
+
+  /**
+   * The plain single-colour spline branch of beginEdge — lifted verbatim so the
+   * four-way spline-kind chain above stays readable; no branch was reordered or
+   * merged. splines=ortho + radius/style=rounded emits straight segments plus
+   * corner arcs as polylines (L), else the bezier itself.
+   * @see lib/common/emit.c:2583
+   */
+  protected emitPlainSpline(e: Edge, list: Bezier[], edraw: string[], job: RenderJob): void {
+    const radius = orthoRoundedRadius(e, job);
+    const obj = job.obj;
+    const origStyle = obj !== null ? [...obj.rawStyle] : [];
+    const multi = list.length > 1;
+    for (const bez of list) {
+      this.emitSplineBezier(bez, radius, edraw, job);
+      // arrow_gen (drawn to TDRAW/HDRAW below) resets the job style to
+      // defaultlinestyle ("solid") as a side effect. For a multi-bezier spline
+      // the NEXT segment's xdot_style re-emits the current rawstyle every call,
+      // so a solid edge picks up a bare `S 5 -solid`; C restores the edge's own
+      // styles afterward only when it has explicit ones. @see emit.c:2668-2677
+      if (obj !== null && multi && (bez.sflag || bez.eflag)) {
+        obj.rawStyle = origStyle.length > 0 ? origStyle : ['solid'];
+      }
+    }
+    if (obj !== null) obj.rawStyle = origStyle;
+  }
+
+  /** One bezier of a plain spline: rounded-ortho corner polylines when a radius
+   *  applies and the segment has enough control points, else the bezier. */
+  protected emitSplineBezier(bez: Bezier, radius: number | null, edraw: string[], job: RenderJob): void {
+    const pts = bez.list.slice(0, bez.size);
+    const polys = radius !== null && bez.size >= 4 ? orthoRoundedPolylines(pts, radius) : [];
+    if (polys.length === 0) {
+      edraw.push(this.styleOp(job), this.penOp(job), xdotPoints('B', pts));
+      return;
+    }
+    for (const poly of polys) edraw.push(this.styleOp(job), this.penOp(job), xdotPoints('L', poly));
+  }
+
+  protected emitTaperedSpline(e: Edge, bz: Bezier | undefined, edraw: string[], job: RenderJob): void {
+    if (bz === undefined) return;
+    const radfunc = taperfun(e.attrs.get('dir'), isDirected(e.tail.root));
+    const verts = taper(bz, radfunc, job.obj?.penWidth ?? 1);
+    const edgeColor = job.obj?.penColor ?? { type: 'string', s: 'black' };
+    edraw.push(this.styleOp(job));
+    edraw.push(xdotPenColor(resolveRenderColor('transparent')));
+    edraw.push(xdotFillColor(edgeColor));
+    edraw.push(xdotPoints('P', verts));
+  }
+
+  /**
+   * Emit a split-along-length `;` multicolor edge spline: split each routed
+   * bezier along its arc length into one sub-curve per color segment, drawn
+   * under that segment's pen. Reuses the same split geometry
+   * (splitSplineByColor) as the SVG path. @see lib/common/emit.c:1975 multicolor
+   */
+  protected emitSplitSpline(
+    bzList: (Bezier | undefined)[],
+    colorAttr: string,
+    edraw: string[],
+    job: RenderJob,
+  ): { firstColor: string; endColor: string } {
+    const segs = parseSegs(colorAttr).segs;
+    const firstColor = segs[0]?.color ?? DEFAULT_COLOR;
+    let endColor = firstColor;
+    for (const bz of bzList) {
+      if (bz === undefined || bz.size < 4) continue;
+      const split = splitSplineByColor(bz.list.slice(0, bz.size), segs);
+      endColor = split.endColor;
+      for (const c of split.curves) {
+        edraw.push(this.styleOp(job), xdotPenColor(resolveRenderColor(c.color)), xdotPoints('B', c.points));
+      }
+    }
+    return { firstColor, endColor };
+  }
+
+  /**
+   * Emit the parallel-multicolor edge spline: one offset Bézier per color,
+   * offset SEP=2.0 perpendicular per pass — reusing the same offset geometry
+   * (buildOffsetLists/advanceTmpList) as the SVG parallel-edge path.
+   * @see lib/common/emit.c:2443 (parallel multicolor) / svg-parallel-edge.ts
+   */
+  protected emitParallelSpline(
+    bzList: (Bezier | undefined)[],
+    colorAttr: string,
+    numc: number,
+    edraw: string[],
+    job: RenderJob,
+  ): { headColor: string; tailColor: string } {
+    const segData = bzList.map((bz) =>
+      bz !== undefined && bz.size >= 4
+        ? buildOffsetLists(bz.list, (2 + numc) / 2)
+        : { offlist: [] as Point[], tmplist: [] as Point[] },
+    );
+    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR);
+    for (const color of colors) {
+      const pen = xdotPenColor(resolveRenderColor(color));
+      for (const sd of segData) {
+        if (sd.offlist.length === 0) continue;
+        advanceTmpList(sd.tmplist, sd.offlist);
+        edraw.push(this.styleOp(job), pen, xdotPoints('B', sd.tmplist));
+      }
+    }
+    // C sets headcolor=tailcolor at cnum==0 and tailcolor again at cnum==1, so
+    // the HEAD arrow takes the first colour and the TAIL arrow the second (or
+    // the first when only one was given). Note this is the INVERSE of the `;`
+    // split branch above (tail=first, head=end). @see lib/common/emit.c:2493-2497
+    return {
+      headColor: colors[0] ?? DEFAULT_COLOR,
+      tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR,
+    };
+  }
+
+  /** Emit one arrow's primitive ops into `buf` (pen/fill from the edge color).
+   *  arrow_gen sets the default line style ("solid") and the edge penwidth
+   *  before each primitive, so a non-default penwidth emits `S setlinewidth(N)`
+   *  once (tracked per HDRAW/TDRAW state). @see arrows.c:arrow_gen */
+  protected emitArrows(
+    buf: string[], ops: ArrowDrawOp[] | undefined, job: RenderJob, state: EmitState,
+    penOverride?: string,
+  ): void {
+    if (ops === undefined) return;
+    const pen = penOverride !== undefined
+      ? resolveRenderColor(penOverride)
+      : job.obj?.penColor ?? { type: 'string', s: 'black' };
+    const pw = job.obj?.penWidth ?? 1;
+    for (const op of ops) {
+      if (Math.abs(pw - this.penwidth[state]!) >= 0.0005) {
+        this.penwidth[state] = pw;
+        buf.push(xdotStrOp('S ', 'setlinewidth(' + trimFixed3(pw) + ')'));
+      }
+      buf.push(xdotStrOp('S ', 'solid'));
+      buf.push(xdotPenColor(pen));
+      emitArrowOp(buf, op, pen);
+    }
+  }
+}

package/src/render/dot/types.ts

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/** Shared shapes for the dot/xdot renderer and its agwrite serializer. */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+
+/** Accumulated xdot draw strings for one model object (agset side-table). */
+export interface XdotDraws {
+  draw?: string;
+  ldraw?: string;
+  hdraw?: string;
+  tdraw?: string;
+  hldraw?: string;
+  tldraw?: string;
+}
+
+/** Mutable state threaded through the recursive agwrite serializer. */
+export interface SerCtx {
+  out: string[];
+  /** subgraph → preorder number (write.c:subgdfs). */
+  preorder: Map<Graph, number>;
+  /** node → preorder of the subgraph it was last written in (node_last_written). */
+  nodeLW: Map<Node, number>;
+  /** edge → preorder of the subgraph it was last written in (edge_last_written). */
+  edgeLW: Map<Edge, number>;
+  /** objects whose attributes have already been emitted (AGATTRWF/attrs_written). */
+  attrsWritten: Set<Node | Edge>;
+  /** current indentation depth. */
+  level: number;
+}