@knowvah/dot-engine 1.1.0 → 1.2.0

package/dist/render/dot/types.d.ts

@@ -0,0 +1,28 @@
+/** 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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/render/dot/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/render/dot/types.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAE1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,uEAAuE;AACvE,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,oDAAoD;IACpD,QAAQ,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC7B,kFAAkF;IAClF,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1B,kFAAkF;IAClF,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1B,mFAAmF;IACnF,YAAY,EAAE,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IAC/B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/render/dot/xdot-ops.d.ts

@@ -0,0 +1,206 @@
+/**
+ * xdot output primitives — number, string, colour and geometry formatting for
+ * the xdot draw-string language, plus the shared `%.5g`/`%.2f` helpers.
+ *
+ * @see plugin/core/gvrender_core_dot.c
+ */
+import type { Point } from '../../model/geom.js';
+import type { GVColor } from '../../common/color.js';
+export declare const XDOT_VERSION = "1.7";
+/** Max magnitude cap — matches maxnegnum in C source. */
+export declare const MAX_NEGNUM = 1000000000000000;
+/** Near-zero suppression threshold (same as gvprintdouble). */
+export declare const NEAR_ZERO = 0.005;
+/** Indices 8/9 alias 1; 10/11 alias 5. NUM_XBUFS covers 0–7. */
+export declare const NUM_XBUFS = 8;
+/**
+ * Style tokens that never become an xdot `S` op: `filled`/`bold`/`setlinewidth`
+ * are filtered by xdot_style itself; the polygon/fill styles are consumed by the
+ * shape/fill code before gvrender_set_style, so they never reach the render
+ * style. Only line styles (solid/dashed/dotted + unknown) emit an `S` op.
+ * @see plugin/core/gvrender_core_dot.c:184 xdot_style · lib/common/shapes.c
+ */
+export declare const NON_LINE_STYLES: ReadonlySet<string>;
+/**
+ * Strip trailing zeros (and the decimal point) from a toFixed(3) string,
+ * then collapse a leading "0." or "-0." prefix.
+ */
+export declare function trimAndStrip(s: string): string;
+/**
+ * Convert a double to compact string form for DOT/XDOT output.
+ *
+ * Rules (porting gvprintnum from lib/gvc/gvdevice.c):
+ * - |n| > MAX_NEGNUM → clamped to ±MAX_NEGNUM
+ * - |n| < NEAR_ZERO → "0" (suppresses -0)
+ * - 3 decimal places, trailing zeros and point stripped
+ * - Leading "0." collapsed to "." (e.g. 0.5 → ".5")
+ *
+ * Exported for json.ts (T30) and map.ts (T31).
+ *
+ * @see lib/gvc/gvdevice.c:gvprintnum
+ */
+export declare function printNum(n: number): string;
+/**
+ * Create a 12-slot xbufs array with the canonical aliasing.
+ *
+ * Indices 8–9 (NDraw, EDraw) alias index 1 (CDraw).
+ * Indices 10–11 (NLabel, ELabel) alias index 5 (CLabel).
+ *
+ * @see plugin/core/gvrender_core_dot.c:xbufs
+ */
+export declare function makeXbufs(): string[][];
+/**
+ * Format one xdot draw-op number: 2 decimals, trailing zeros and point trimmed
+ * — mirroring xdot_fmt_num ("%.02f" + agxbuf_trim_zeros). Distinct from
+ * `printNum` (used for the DOT `pos`/`bb`/`width`/`height` attributes), which
+ * keeps more precision; xdot's DRAW ops are emitted at 2 dp by the C engine.
+ * @see plugin/core/gvrender_core_dot.c:126 xdot_fmt_num
+ */
+export declare function xdotNum(v: number): string;
+/**
+ * Format a single xdot point "x y ". xdot is y-up: `Y_invert` defaults false, so
+ * `yDir(y, yOff)` returns `y` unchanged for xdot (only `-Ty` plain/dot invert).
+ * The layout coordinate passes through with NO inversion — unlike the SVG path.
+ * @see lib/common/output.c:36 yDir · plugin/core/gvrender_core_dot.c:132 xdot_point
+ */
+export declare function xdotPoint(p: Point): string;
+/** Format N points preceded by opcode and count: "<c> <n> x0 y0 x1 y1 …". */
+export declare function xdotPoints(c: string, pts: Point[]): string;
+/**
+ * UTF-8 byte length of a string — the value C's `xdot_str` writes as the length
+ * prefix (`strlen(s)` over the UTF-8 bytes), NOT the JS UTF-16 code-unit count.
+ * A label like `ÿ` (U+00FF) is 2 UTF-8 bytes, so its `T`/`F` op prefix is 2.
+ * @see plugin/core/gvrender_core_dot.c:83 xdot_str_xbuf (`%zu`, strlen)
+ */
+export declare function utf8Len(s: string): number;
+/** Clamp a normalized [0,1] float channel to a 0-255 byte (round-to-nearest). */
+export declare function chanByte(v: number): number;
+/**
+ * Resolve a GVColor to RGBA bytes — the value the C xdot callbacks read from
+ * `job->obj->pencolor.u.rgba` (already resolved by gvrender_set_pencolor). A
+ * plain `rgba` passes through; named/hex/HSV specs run through colorxlate; a
+ * `none` color is fully transparent black (callers gate on PEN_NONE).
+ */
+export declare function gvColorRgba(c: GVColor): [number, number, number, number];
+/**
+ * Bare xdot color body (no `c `/`C ` prefix): the CONSTANT length prefix
+ * (7 for `#rrggbb`, 9 for `#rrggbbaa`) plus `-#hex`, the alpha byte present only
+ * when not fully opaque. Used both by the color ops and by gradient color stops.
+ * @see plugin/core/gvrender_core_dot.c:99 xdot_str_color_xbuf
+ */
+export declare function xdotColorBody(rgba: [number, number, number, number]): string;
+/**
+ * Format an xdot color op ("c "/"C ") from RGBA bytes.
+ * @see plugin/core/gvrender_core_dot.c:99 xdot_str_color_xbuf
+ */
+export declare function xdotColorOp(prefix: 'c ' | 'C ', rgba: [number, number, number, number]): string;
+/**
+ * Build the linear-gradient `C len -[x0 y0 x1 y1 2 <stops>]` fill op. Endpoints
+ * come from getGradientPoints (the same geometry the SVG gradient uses); stops
+ * are (frac,fill)/(frac,stop) when frac>0, else (0,fill)/(1,stop). Shared by
+ * node/cluster gradient fills and the graph-background gradient.
+ * @see plugin/core/gvrender_core_dot.c:544-598 xdot_gradient_fillcolor
+ */
+export declare function linearGradientOp(pts: Point[], fillColor: GVColor, stopColor: GVColor, frac: number, angleDeg: number): string;
+/** The `<frac> <colorbody>` stop pairs for a gradient (frac>0 vs the 0/1 form). */
+export declare function gradientStops(fillColor: GVColor, stopColor: GVColor, frac: number): string;
+/**
+ * Build the radial-gradient `C len -(c1x c1y r1 c2x c2y r2 2 <stops>)` fill op.
+ * Reuses getGradientPoints (radial) for the center/radii, un-negating its SVG
+ * y. r1 = outerR/4, r2 = outerR; c2 is the center, c1 the center offset by r1
+ * along the gradient angle (== center when angle 0).
+ * @see plugin/core/gvrender_core_dot.c:562-585 xdot_gradient_fillcolor (radial)
+ */
+export declare function radialGradientOp(pts: Point[], fillColor: GVColor, stopColor: GVColor, frac: number, angleDeg: number): string;
+/** Pen ("c ") color op from a resolved GVColor. */
+export declare function xdotPenColor(c: GVColor): string;
+/** Fill ("C ") color op from a resolved GVColor. */
+export declare function xdotFillColor(c: GVColor): string;
+/**
+ * Build the xdot "F size len -name " font op. Mirrors xdot_textspan's `F` +
+ * `xdot_str(job, "", font->name)` — the length prefix is the byte length of the
+ * face name. @see plugin/core/gvrender_core_dot.c:498 xdot_textspan
+ */
+export declare function xdotFont(size: number, name: string): string;
+/**
+ * Build an xdot length-prefixed string op ("S "/"" prefix): "<pfx><len> -<s> ".
+ * @see plugin/core/gvrender_core_dot.c:83 xdot_str_xbuf
+ */
+export declare function xdotStrOp(prefix: string, s: string): string;
+/**
+ * Quote a DOT identifier unless it is a bare id or numeral, mirroring agwrite's
+ * agcanonStr so the serialized graph reparses (the comparator reparses both
+ * sides). Only `"` is escaped (→ `\"`); a `\` is left as-is — it is already the
+ * start of a stored escape like `\n`/`\l` that agcanonStr keeps verbatim, so
+ * doubling it (`\\n`) would change the name (`a\n(b\n"c")` must stay `a\n…`, not
+ * `a\\n…`). Over-quoting a value native leaves bare is harmless: both parse to
+ * the same name. @see lib/cgraph/write.c:_agstrcanon (escapes '"', keeps '\')
+ *
+ * ONE DELIBERATE DIVERGENCE from _agstrcanon: an ODD trailing backslash run is
+ * padded to even. C copies it verbatim and appends the closing quote, so a name
+ * ending in a single `\` serializes as `"a\"` — the backslash escapes the quote
+ * and the output does not reparse. The DOT lexer cannot produce such a name
+ * (source `"a\"` never terminates), so this is unreachable from any file and no
+ * corpus id changes; it is reachable only through the programmatic API, where a
+ * caller supplies the string directly. Padding costs a name that round-trips to
+ * `a\\` instead of `a\`, which beats emitting a document that cannot be parsed.
+ * @see CodeQL "Incomplete string escaping or encoding" — the alert's own remedy
+ *      (escape every `\`) is wrong here and breaks `\n`/`\l` parity.
+ */
+export declare function xdotId(s: string): string;
+/**
+ * Format a number as C's `%.5g` — 5 significant figures, trailing zeros and
+ * point trimmed, switching to `e±NN` (min 2 exponent digits) when the exponent
+ * is < -4 or ≥ 5. Native writes the DOT `pos`/`bb`/`width`/`height` attributes
+ * with `%.5g` (output.c:71/294/302), so large coordinates round to 5 sig figs
+ * (`2219962` → `2.2201e+06`); `printNum`'s fixed 3 dp keeps too much precision.
+ *
+ * Uses {@link printfSig} rather than `Number.prototype.toPrecision(5)` so
+ * exact-halfway values (e.g. 1399.25) round half-to-even like C's snprintf,
+ * not half-away-from-zero like `toPrecision`. @see docs proven case
+ * graphs-b786 (circo): pos coordinate 1399.25 → native "1399.2", `toPrecision`
+ * gave "1399.3".
+ * @see lib/common/output.c:71 (agxbprint "%.5g")
+ */
+export declare function gfmt5(v: number): string;
+/**
+ * Format a number as C's `%.2f` — fixed 2 decimals, half-to-even on exact ties.
+ * `attach_attrs` writes the graph-label size attributes `lwidth`/`lheight` in
+ * INCHES with `%.2f`, unlike every other computed attribute (which uses `%.5g`).
+ * @see lib/common/output.c:244-247 (agxbprint "%.2f", PS2INCH)
+ */
+export declare function gfmt2(v: number): string;
+/**
+ * Format a label position as the `x,y` pair every computed `*_lp` attribute
+ * uses: both coordinates at `%.5g`. C passes y through `yDir()`, which is the
+ * identity unless `Y_invert` — and `Y_invert` is only set by `-Ty` (plain/dot),
+ * never for xdot — so no inversion is applied here, exactly as the existing
+ * `pos`/`bb` emission does.
+ * @see lib/common/output.c:35 yDir · lib/common/output.c:241 (agxbprint "%.5g,%.5g")
+ */
+export declare function lpStr(p: Point): string;
+/**
+ * Escape backslashes in a LABEL draw string — C's put_escaping_backslashes,
+ * applied to the `_ldraw_`/`_hldraw_`/`_tldraw_` buffers (not the shape draws)
+ * before agset. A literal `\` in a label's text (e.g. `WXYZ\nabc`) becomes `\\`
+ * so it survives the DOT string round-trip; the T-op byte-length prefix stays on
+ * the UNescaped text. @see plugin/core/gvrender_core_dot.c:218 put_escaping_backslashes
+ */
+export declare function escBackslash(s: string): string;
+/** True if s[i..] starts an escape sequence agcanonStr keeps verbatim: a `\`
+ *  followed by one of E G H L N T l n r \ ". @see lib/cgraph/write.c:is_escape */
+export declare function isEscapeSeq(s: string, i: number): boolean;
+/**
+ * Escape a value for a DOT attribute exactly as agwrite's agcanonStr does: a `"`
+ * becomes `\"` ONLY when it is not already part of an escape sequence, so an
+ * existing `\"` or `\\` in the value is passed through verbatim rather than
+ * double-escaped. For an already-backslash-doubled value (node/edge/graph labels,
+ * post put_escaping_backslashes) this is identical to a naive `"`→`\"` — every
+ * `"` follows a doubled `\\`, so none are ever part_of_escape. For raw cluster
+ * labels (agset, no put_escaping) it preserves the source `\"`/`\\` unchanged.
+ * @see lib/cgraph/write.c:_agstrcanon (135-167)
+ */
+export declare function agcanonEscape(s: string): string;
+/** Trim a "%.3f" fixed string like C's agxbuf_trim_zeros (trailing 0s + dot). */
+export declare function trimFixed3(v: number): string;
+//# sourceMappingURL=xdot-ops.d.ts.map

package/dist/render/dot/xdot-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xdot-ops.d.ts","sourceRoot":"","sources":["../../../src/render/dot/xdot-ops.ts"],"names":[],"mappings":"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"}

package/dist/render/dot.d.ts

@@ -12,171 +12,14 @@ import type { Node } from '../model/node.js';
 import type { Edge } from '../model/edge.js';
 import type { Point } from '../model/geom.js';
 import type { TextSpan } from '../common/emit-types.js';
-import type { GVColor } from '../common/color.js';
 import type { RendererPlugin } from '../gvc/context.js';
+import { EdgeDrawBase } from './dot/edge-draw.js';
+export * from './dot/types.js';
+export type { XdotDraws, SerCtx } from './dot/types.js';
+import type { XdotDraws } from './dot/types.js';
 import type { RenderJob } from '../gvc/job.js';
-/**
- * Convert a double to compact string form for DOT/XDOT output.
- *
- * Rules (porting gvprintnum from lib/gvc/gvdevice.c):
- * - |n| > MAX_NEGNUM → clamped to ±MAX_NEGNUM
- * - |n| < NEAR_ZERO → "0" (suppresses -0)
- * - 3 decimal places, trailing zeros and point stripped
- * - Leading "0." collapsed to "." (e.g. 0.5 → ".5")
- *
- * Exported for json.ts (T30) and map.ts (T31).
- *
- * @see lib/gvc/gvdevice.c:gvprintnum
- */
-export declare function printNum(n: number): string;
-/**
- * Create a 12-slot xbufs array with the canonical aliasing.
- *
- * Indices 8–9 (NDraw, EDraw) alias index 1 (CDraw).
- * Indices 10–11 (NLabel, ELabel) alias index 5 (CLabel).
- *
- * @see plugin/core/gvrender_core_dot.c:xbufs
- */
-export declare function makeXbufs(): string[][];
-/**
- * Format one xdot draw-op number: 2 decimals, trailing zeros and point trimmed
- * — mirroring xdot_fmt_num ("%.02f" + agxbuf_trim_zeros). Distinct from
- * `printNum` (used for the DOT `pos`/`bb`/`width`/`height` attributes), which
- * keeps more precision; xdot's DRAW ops are emitted at 2 dp by the C engine.
- * @see plugin/core/gvrender_core_dot.c:126 xdot_fmt_num
- */
-export declare function xdotNum(v: number): string;
-/**
- * Format a single xdot point "x y ". xdot is y-up: `Y_invert` defaults false, so
- * `yDir(y, yOff)` returns `y` unchanged for xdot (only `-Ty` plain/dot invert).
- * The layout coordinate passes through with NO inversion — unlike the SVG path.
- * @see lib/common/output.c:36 yDir · plugin/core/gvrender_core_dot.c:132 xdot_point
- */
-export declare function xdotPoint(p: Point): string;
-/** Format N points preceded by opcode and count: "<c> <n> x0 y0 x1 y1 …". */
-export declare function xdotPoints(c: string, pts: Point[]): string;
-/**
- * UTF-8 byte length of a string — the value C's `xdot_str` writes as the length
- * prefix (`strlen(s)` over the UTF-8 bytes), NOT the JS UTF-16 code-unit count.
- * A label like `ÿ` (U+00FF) is 2 UTF-8 bytes, so its `T`/`F` op prefix is 2.
- * @see plugin/core/gvrender_core_dot.c:83 xdot_str_xbuf (`%zu`, strlen)
- */
-export declare function utf8Len(s: string): number;
-/**
- * Resolve a GVColor to RGBA bytes — the value the C xdot callbacks read from
- * `job->obj->pencolor.u.rgba` (already resolved by gvrender_set_pencolor). A
- * plain `rgba` passes through; named/hex/HSV specs run through colorxlate; a
- * `none` color is fully transparent black (callers gate on PEN_NONE).
- */
-export declare function gvColorRgba(c: GVColor): [number, number, number, number];
-/**
- * Bare xdot color body (no `c `/`C ` prefix): the CONSTANT length prefix
- * (7 for `#rrggbb`, 9 for `#rrggbbaa`) plus `-#hex`, the alpha byte present only
- * when not fully opaque. Used both by the color ops and by gradient color stops.
- * @see plugin/core/gvrender_core_dot.c:99 xdot_str_color_xbuf
- */
-export declare function xdotColorBody(rgba: [number, number, number, number]): string;
-/**
- * Format an xdot color op ("c "/"C ") from RGBA bytes.
- * @see plugin/core/gvrender_core_dot.c:99 xdot_str_color_xbuf
- */
-export declare function xdotColorOp(prefix: 'c ' | 'C ', rgba: [number, number, number, number]): string;
-/**
- * Build the linear-gradient `C len -[x0 y0 x1 y1 2 <stops>]` fill op. Endpoints
- * come from getGradientPoints (the same geometry the SVG gradient uses); stops
- * are (frac,fill)/(frac,stop) when frac>0, else (0,fill)/(1,stop). Shared by
- * node/cluster gradient fills and the graph-background gradient.
- * @see plugin/core/gvrender_core_dot.c:544-598 xdot_gradient_fillcolor
- */
-export declare function linearGradientOp(pts: Point[], fillColor: GVColor, stopColor: GVColor, frac: number, angleDeg: number): string;
-/**
- * Build the radial-gradient `C len -(c1x c1y r1 c2x c2y r2 2 <stops>)` fill op.
- * Reuses getGradientPoints (radial) for the center/radii, un-negating its SVG
- * y. r1 = outerR/4, r2 = outerR; c2 is the center, c1 the center offset by r1
- * along the gradient angle (== center when angle 0).
- * @see plugin/core/gvrender_core_dot.c:562-585 xdot_gradient_fillcolor (radial)
- */
-export declare function radialGradientOp(pts: Point[], fillColor: GVColor, stopColor: GVColor, frac: number, angleDeg: number): string;
-/** Pen ("c ") color op from a resolved GVColor. */
-export declare function xdotPenColor(c: GVColor): string;
-/** Fill ("C ") color op from a resolved GVColor. */
-export declare function xdotFillColor(c: GVColor): string;
-/**
- * Build the xdot "F size len -name " font op. Mirrors xdot_textspan's `F` +
- * `xdot_str(job, "", font->name)` — the length prefix is the byte length of the
- * face name. @see plugin/core/gvrender_core_dot.c:498 xdot_textspan
- */
-export declare function xdotFont(size: number, name: string): string;
-/**
- * Quote a DOT identifier unless it is a bare id or numeral, mirroring agwrite's
- * agcanonStr so the serialized graph reparses (the comparator reparses both
- * sides). Only `"` is escaped (→ `\"`); a `\` is left as-is — it is already the
- * start of a stored escape like `\n`/`\l` that agcanonStr keeps verbatim, so
- * doubling it (`\\n`) would change the name (`a\n(b\n"c")` must stay `a\n…`, not
- * `a\\n…`). Over-quoting a value native leaves bare is harmless: both parse to
- * the same name. @see lib/cgraph/write.c:_agstrcanon (escapes '"', keeps '\')
- */
-export declare function xdotId(s: string): string;
-/**
- * Format a number as C's `%.5g` — 5 significant figures, trailing zeros and
- * point trimmed, switching to `e±NN` (min 2 exponent digits) when the exponent
- * is < -4 or ≥ 5. Native writes the DOT `pos`/`bb`/`width`/`height` attributes
- * with `%.5g` (output.c:71/294/302), so large coordinates round to 5 sig figs
- * (`2219962` → `2.2201e+06`); `printNum`'s fixed 3 dp keeps too much precision.
- *
- * Uses {@link printfSig} rather than `Number.prototype.toPrecision(5)` so
- * exact-halfway values (e.g. 1399.25) round half-to-even like C's snprintf,
- * not half-away-from-zero like `toPrecision`. @see docs proven case
- * graphs-b786 (circo): pos coordinate 1399.25 → native "1399.2", `toPrecision`
- * gave "1399.3".
- * @see lib/common/output.c:71 (agxbprint "%.5g")
- */
-export declare function gfmt5(v: number): string;
-/** Format node attributes for DOT output. */
-export declare function formatNodeAttrs(n: Node): string;
-/**
- * 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. @see lib/common/output.c:357-372
- */
-export declare function formatEdgePos(e: Edge): string;
-/** Return the edge connector token. */
-export declare function edgeConnector(directed: boolean): string;
-/** Return true if the graph is directed or strict-directed. */
-export declare function isDirected(g: Graph): boolean;
-/** Emit the opening digraph/graph line and bb attribute. */
-export declare function dotBeginGraphHeader(g: Graph, job: RenderJob): void;
-/**
- * DOT format renderer — writes graphviz DOT language with layout attributes.
- *
- * @see plugin/core/gvrender_core_dot.c:dot_engine
- */
-export declare class DotRenderer implements RendererPlugin {
-    readonly type = "dot";
-    /** @see plugin/core/gvplugin_core.c registration table */
-    readonly quality = 0;
-    beginGraph(g: Graph, job: RenderJob): void;
-    endGraph(_g: Graph, job: RenderJob): void;
-    beginNode(_n: Node, _job: RenderJob): void;
-    endNode(n: Node, job: RenderJob): void;
-    beginEdge(_e: Edge, _job: RenderJob): void;
-    endEdge(e: Edge, job: RenderJob): void;
-    textspan(_pos: Point, _span: TextSpan, _job: RenderJob): void;
-    ellipse(_c: Point, _rx: number, _ry: number, _f: boolean, _j: RenderJob): void;
-    polygon(_pts: Point[], _filled: boolean, _job: RenderJob): void;
-    bezier(_pts: Point[], _filled: boolean, _job: RenderJob): void;
-    polyline(_pts: Point[], _job: RenderJob): void;
-}
-/** 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;
-}
+export * from './dot/xdot-ops.js';
+export * from './dot/attrs.js';
 /**
  * XDOT format renderer — mirrors plugin/core/gvrender_core_dot.c's xdot engine.
  *
@@ -192,27 +35,33 @@ export interface XdotDraws {
  *
  * @see plugin/core/gvrender_core_dot.c xdot_begin_graph / xdot_end_graph
  */
-export declare class XdotRenderer implements RendererPlugin {
-    readonly type = "xdot";
+export declare class XdotRenderer extends EdgeDrawBase implements RendererPlugin {
+    readonly type: string;
     /** @see plugin/core/gvplugin_core.c registration table */
     readonly quality = 0;
+    /**
+     * Whether this format attaches the xdot draw attributes before agwrite.
+     * Mirrors C's `job->render.id` switch: FORMAT_DOT runs `attach_attrs(g)` then
+     * `agwrite`, while FORMAT_XDOT runs `attach_attrs_and_arrows` +
+     * `xdot_begin_graph`/`xdot_end_graph` and *then* the same `agwrite`. The
+     * serializer below is that shared `agwrite`; this flag is the only difference.
+     * @see plugin/core/gvrender_core_dot.c:404,418,475,482
+     */
+    protected readonly emitDraws: boolean;
+    /** Draw strings for `obj`, or undefined in a format that emits none (`-Tdot`).
+     *  Single gate so the xdot path cannot drift from the dot path. */
+    protected drawsOf(obj: Node | Edge | Graph): XdotDraws | undefined;
     /** Per-render draw buffers. Indices 8/9 alias 1; 10/11 alias 5. */
     private bufs;
-    /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
-    private penwidth;
     /** text-flag state per emit_state. @see gvrender_core_dot.c textflags[] */
     private textflags;
     /** Accumulated draw strings keyed by model object (C: agset on the object). */
     private draws;
-    /** Clusters in render order — the graphs `endCluster` was actually called for
-     *  (from `renderClusters`/`GD_clust`), which is NOT always reachable via
-     *  `g.subgraphs`, so it is tracked here rather than re-walked. */
-    private clusters;
     /** edge_in_box gate for the current edge: emit_edge draws nothing (spline OR
      *  label) for an edge whose content is outside job->clip. Mirrors svg.ts's
      *  edgeGroupOpen. @see lib/common/emit.c:emit_edge (3039) */
     private edgeDrawable;
-    beginGraph(g: Graph, _job: RenderJob): void;
+    beginGraph(_g: Graph, _job: RenderJob): void;
     /** The per-object draw strings accumulated during the last render, keyed by
      *  the ORIGINAL model object. These are the pre-serialization values C's
      *  `-Tjson` reads directly (via agxget) — feeding them to parseXDot avoids the
@@ -223,6 +72,10 @@ export declare class XdotRenderer implements RendererPlugin {
     /** Emit the canvas background polygon into the GDRAW buffer.
      *  @see lib/common/emit.c:1476 emit_background */
     pageBackground(g: Graph, job: RenderJob): void;
+    /** The canvas fill op: a two-colour `bgcolor` is a gradient (emit_background →
+     *  findStopColor), linear or radial per style; anything else is a flat fill.
+     *  @see lib/common/emit.c:1476 emit_background */
+    private backgroundFillOp;
     beginNode(_n: Node, _job: RenderJob): void;
     endNode(n: Node, _job: RenderJob): void;
     /**
@@ -240,27 +93,14 @@ export declare class XdotRenderer implements RendererPlugin {
      * -tapered` (the style), a transparent pen, the edge-color fill, then the
      * polygon vertices from `taper()` (y-up). @see lib/common/emit.c:2422
      */
-    private emitTaperedSpline;
-    /**
-     * 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
-     */
-    private emitSplitSpline;
-    /**
-     * 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
-     */
-    private emitParallelSpline;
-    /** 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 */
-    private emitArrows;
     endEdge(e: Edge, job: RenderJob): void;
+    /** Flush the six edge buffers and attach the non-empty ones. Label buffers get
+     *  put_escaping_backslashes; shape buffers do not.
+     *  @see plugin/core/gvrender_core_dot.c:218 */
+    private attachEdgeDraws;
+    /** Per-edge emit-state reset, run on both the drawable and the early-return
+     *  path — identical in C, so it is one helper here rather than two copies. */
+    private resetEdgeState;
     beginCluster(_sg: Graph, _job: RenderJob): void;
     endCluster(sg: Graph, _job: RenderJob): void;
     textspan(pos: Point, span: TextSpan, job: RenderJob): void;
@@ -269,7 +109,7 @@ export declare class XdotRenderer implements RendererPlugin {
     bezier(pts: Point[], filled: boolean, job: RenderJob): void;
     polyline(pts: Point[], job: RenderJob): void;
     /** Pen color op from the resolved graphics state (default black). */
-    private penOp;
+    protected penOp(job: RenderJob): string;
     /**
      * Fill op from the resolved graphics state. A linear gradient emits the
      * bracketed `C len -[G0 G1 2 <stops>]` form (xdot_gradient_fillcolor); a plain
@@ -280,7 +120,7 @@ export declare class XdotRenderer implements RendererPlugin {
     private fillOp;
     /** Style ops (`S`): setlinewidth on a penwidth change, plus dash/dot pen.
      *  @see gvrender_core_dot.c:161 xdot_style */
-    private styleOp;
+    protected styleOp(job: RenderJob): string;
     /** Active xdot buffer for the current emit state. */
     private getBuf;
     /** Join and clear the buffer for `state`; returns '' when empty. */
@@ -288,89 +128,30 @@ export declare class XdotRenderer implements RendererPlugin {
     /** Reset per-emit-state penwidth/textflags after an object (C's reset). */
     private resetState;
     private drawsFor;
-    /**
-     * Emit `key="value"`, escaping the value the way agwrite's agcanonStr does: a
-     * `"` becomes `\"` unless it is already part of an escape sequence (see
-     * agcanonEscape). A draw string carries label text that may contain a bare `"`
-     * (would close the attribute early) or a source `\"`/`\\` (must not be
-     * double-escaped). The byte-length prefix stays on the UNescaped text (the
-     * parser un-escapes before parseXDot re-reads it), matching native exactly.
-     * @see lib/cgraph/write.c:_agstrcanon (135-167)
-     */
-    private drawAttr;
-    /** `llx,lly,urx,ury` from a graph's layout bb. */
-    private bbStr;
-    /**
-     * Serialize the whole laid-out graph to xdot DOT text — a faithful port of
-     * cgraph's agwrite (lib/cgraph/write.c). Recurses the subgraph tree
-     * (write_subgs/write_body), scoping each node/edge to the subgraph(s) it
-     * belongs to via preorder numbers (write_node_test/write_edge_test), and
-     * re-emits an object bare (no attrs) on any scope after the first
-     * (attrs_written). This reproduces native's per-subgraph edge re-declarations
-     * — e.g. an edge in a rank=same subgraph is drawn once, then re-declared bare.
-     * @see lib/cgraph/write.c:agwrite
-     */
-    private serialize;
-    /** Preorder-number the subgraph tree. @see write.c:subgdfs */
-    private subgdfs;
-    /** A subgraph is anonymous when its name is empty or a `%N` local name. */
-    private isAnonymous;
-    /** A graph carries a `bb` attribute when it is the root or has a layout bb
-     *  (clusters, and any subgraph output.c computed a box for). Native seeds `bb`
-     *  on every graph via safe_dcl, so the value differs (set vs empty "") between
-     *  a boxed graph and an unboxed child — the driver that makes an anon subgraph
-     *  under the root or a cluster "relevant". @see lib/common/output.c:safe_dcl */
-    private hasBb;
-    /** Anonymous subgraph with no own node/edge defaults and no graph attrs
-     *  differing from its parent → inlined into the parent. Native compares every
-     *  graph attr over the root attr dict; the load-bearing ones are `bb` (set on
-     *  the parent, empty on the child) and `rank`. @see write.c:irrelevant_subgraph */
-    private irrelevantSubgraph;
-    /** Non-draw graph attrs a subgraph emits (rank for rank=same; clusters use
-     *  clusterAttrs). Only comparator-relevant fields need be exact.
-     *
-     *  `rec_attach_bb` walks the ROOT and then `GD_clust` recursively, so a
-     *  subgraph the layout did not box is attached NEITHER `bb` NOR the label
-     *  triple — both keep the INPUT's values, which agwrite echoes. circo and
-     *  twopi lay out no clusters at all (`GD_clust` empty — mirrored here by
-     *  `this.clusters`, filled from endCluster), so on a re-fed dot output their
-     *  `cluster0` comes back carrying the *previous* run's `bb` and `lp`.
-     *  @see lib/common/output.c:249 rec_attach_bb */
-    private subgGraphAttrs;
-    private indent;
-    /** @see write.c:write_hdr */
-    private writeHdr;
-    /** @see write.c:write_trl */
-    private writeTrl;
-    /** @see write.c:write_subgs */
-    private writeSubgs;
-    /** @see write.c:write_body — subgraphs, then this scope's nodes and edges. */
-    private writeBody;
-    /** @see write.c:write_node_test — every xdot node carries pos/size, so it is
-     *  never "default"; write it in the first scope that has not yet emitted it.
-     *  Cluster nodes (fdp compound proxies, ND_clustnode) are never declared —
-     *  C's write_plain/writenodeandport suppress them. @see lib/common/output.c:146 */
-    private writeNodeTest;
-    /** Emitted node name: a cluster node's synthetic `__i:<cluster>` id is written
-     *  as the cluster name it stands for. @see lib/common/output.c:114 */
-    private emitNodeName;
-    /** @see write.c:write_edge_test */
-    private writeEdgeTest;
-    /** @see write.c:write_node */
-    private writeNode;
-    /** @see write.c:write_edge — attrs only on first emission, bare thereafter. */
-    private writeEdge;
-    /** Root-graph attribute block: `_draw_`, `_ldraw_`, `bb`, `xdotversion`. */
-    private graphAttrs;
-    /** Cluster attribute block. C's xdot_end_cluster ALWAYS agsets `_draw_` when
-     *  the graph has clusters (even empty, e.g. peripheries=0), so emit it
-     *  unconditionally; `_ldraw_` only when the cluster has a label.
-     *  @see plugin/core/gvrender_core_dot.c:284 xdot_end_cluster */
-    private clusterAttrs;
-    /** Node attribute block: pos/width/height plus `_draw_`/`_ldraw_`. */
-    private nodeAttrs;
-    /** The `[...]` attribute body for an edge (draw ops + spline `pos`), or ''. */
-    private edgeAttrStr;
+}
+/**
+ * DOT format renderer (`-Tdot`) — the same engine as {@link XdotRenderer} with
+ * the xdot draw-attribute step switched off, mirroring C's one renderer with a
+ * `job->render.id` switch: FORMAT_DOT is `attach_attrs(g)` then `agwrite(g)`,
+ * FORMAT_XDOT is `attach_attrs_and_arrows` + the `xdot_*` draw attributes then
+ * *the same* `agwrite(g)`. Sharing the serializer is what makes `-Tdot` emit the
+ * subgraph tree, per-scope node/edge scoping, and the `node [label="\N"]`
+ * default line, none of which a streaming emitter can produce (the whole graph
+ * must be walked before the first byte).
+ *
+ * The drawing callbacks are overridden to no-ops: `-Tdot` renders no draw ops,
+ * so accumulating them would be dead work.
+ *
+ * @see plugin/core/gvrender_core_dot.c:398 dot_begin_graph / :464 dot_end_graph
+ */
+export declare class DotRenderer extends XdotRenderer {
+    readonly type: string;
+    protected readonly emitDraws: boolean;
+    textspan(_pos: Point, _span: TextSpan, _job: RenderJob): void;
+    ellipse(_c: Point, _rx: number, _ry: number, _f: boolean, _j: RenderJob): void;
+    polygon(_pts: Point[], _filled: boolean, _job: RenderJob): void;
+    bezier(_pts: Point[], _filled: boolean, _job: RenderJob): void;
+    polyline(_pts: Point[], _job: RenderJob): void;
 }
 /** @see plugin/core/gvrender_core_dot.c FORMAT_DOT */
 export declare function createDotRenderer(): RendererPlugin;