@knowvah/dot-engine 1.1.1 → 1.2.1

package/dist/render.js

@@ -7367,6 +7367,7 @@ function bezierClip(insideCtx, insideFn, sp, leftInside) {
 
 // src/common/arrows-constants.ts
 var ARROW_LENGTH = 10;
+var NUMB_OF_ARROW_HEADS = 4;
 var BITS_PER_ARROW_TYPE = 4;
 var ARR_TYPE_NONE = 0;
 var ARR_TYPE_NORM = 1;
@@ -7480,13 +7481,18 @@ var parseOne = (s) => {
 function parseArrow(str) {
   const result = [];
   let s = str;
-  while (s.length > 0) {
+  let parsedAny = false;
+  while (s.length > 0 && result.length < NUMB_OF_ARROW_HEADS) {
     const m = parseOne(s);
     if (!m) break;
-    result.push(m.comp);
+    parsedAny = true;
     s = m.rest;
+    const isGap = m.comp.name === "none";
+    if (isGap && result.length === NUMB_OF_ARROW_HEADS - 1) continue;
+    if (isGap && result.length === 0 && s.length === 0) continue;
+    result.push(m.comp);
   }
-  if (result.length === 0) result.push({ name: "normal", open: false, left: false, right: false });
+  if (!parsedAny) result.push({ name: "normal", open: false, left: false, right: false });
   return result;
 }
 var NAME_TO_FLAG = /* @__PURE__ */ new Map([
@@ -8144,6 +8150,32 @@ function arrowDrawOpsForEnd(e, end, tip2, dir, penwidth) {
   return arrowDrawOps(comps, tip2, dir, edgeArrowsize(e), penwidth);
 }
 
+// src/model/layoutParams.ts
+var FontnameKind = {
+  NativeFonts: 0,
+  PsFonts: 1,
+  SvgFonts: 2
+};
+function makeDrawing(overrides) {
+  const zero = { x: 0, y: 0 };
+  return {
+    quantum: 0,
+    scale: 0,
+    ratio: 0,
+    dpi: 0,
+    margin: { ...zero },
+    page: { ...zero },
+    size: { ...zero },
+    filled: false,
+    landscape: false,
+    centered: false,
+    ratioKind: "none",
+    xdots: null,
+    id: null,
+    ...overrides
+  };
+}
+
 // src/util/printf-round.ts
 function decomposeFloat64(v) {
   const buf = new DataView(new ArrayBuffer(8));
@@ -8376,6 +8408,9 @@ var RenderJob = class {
   radialGradId = 0;
   /** Whether the graph being rendered is directed (edge titles use -> vs --). */
   directed = true;
+  /** GD_fontnames of the root graph — selects which PostScript-alias fields the
+   *  SVG emitter uses. @see plugin/core/gvrender_core_svg.c:464 */
+  fontnames = FontnameKind.NativeFonts;
   /** Root graph's `id` attribute (GD_drawing(root)->id), '' if unset. Used as
    * the `<gid>_` prefix for non-root object ids. @see lib/common/emit.c:getObjId */
   drawingId = "";
@@ -8486,32 +8521,6 @@ function boxOverlap(b0, b1) {
 }
 var POINTS_PER_INCH = 72;
 
-// src/model/layoutParams.ts
-var FontnameKind = {
-  NativeFonts: 0,
-  PsFonts: 1,
-  SvgFonts: 2
-};
-function makeDrawing(overrides) {
-  const zero = { x: 0, y: 0 };
-  return {
-    quantum: 0,
-    scale: 0,
-    ratio: 0,
-    dpi: 0,
-    margin: { ...zero },
-    page: { ...zero },
-    size: { ...zero },
-    filled: false,
-    landscape: false,
-    centered: false,
-    ratioKind: "none",
-    xdots: null,
-    id: null,
-    ...overrides
-  };
-}
-
 // src/model/graphInfo.ts
 function makeGraphInfo() {
   return {
@@ -9879,6 +9888,13 @@ function emitHtmlImg(img, pos, renderer, job) {
   }
   renderer.usershape?.(img.src, b, job);
 }
+function htmlStyleInvisible(style) {
+  if (style === void 0) return false;
+  return style.split(/[ ,]+/).some((tok) => {
+    const t = tok.toUpperCase();
+    return t === "INVIS" || t === "INVISIBLE";
+  });
+}
 function emitHtmlCell(cell2, pos, renderer, job) {
   const inAnchor = initHtmlAnchor(
     { href: cell2.href, title: cell2.title, target: cell2.target, id: cell2.id },
@@ -9886,6 +9902,10 @@ function emitHtmlCell(cell2, pos, renderer, job) {
     renderer,
     job
   );
+  if (htmlStyleInvisible(cell2.style)) {
+    if (inAnchor) endHtmlAnchor(renderer, job);
+    return;
+  }
   emitCellDecoration(cell2, pos, renderer, job);
   if (cell2.nested !== void 0) {
     emitHtmlLabel(cell2.nested, pos, renderer, job);
@@ -9918,22 +9938,25 @@ function emitHtmlLabel(placed, pos, renderer, job) {
   const tblBox = absBox(placed.box, pos);
   const clustersLast = (job.flags & EMIT_CLUSTERS_LAST) !== 0;
   const inAnchor = clustersLast ? false : initHtmlAnchor(anchorData, tblBox, renderer, job);
-  if (placed.bgcolor !== void 0) {
-    emitBgFill({
-      bgcolor: placed.bgcolor,
-      box: placed.box,
-      pos,
-      border: placed.border,
-      renderer,
-      job,
-      gradientangle: placed.gradientangle,
-      style: placed.style
-    });
-  }
-  for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
-  emitTableRules(placed, pos, renderer, job);
-  if (placed.border > 0) {
-    emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
+  const tblInvisible = htmlStyleInvisible(placed.style);
+  if (!tblInvisible) {
+    if (placed.bgcolor !== void 0) {
+      emitBgFill({
+        bgcolor: placed.bgcolor,
+        box: placed.box,
+        pos,
+        border: placed.border,
+        renderer,
+        job,
+        gradientangle: placed.gradientangle,
+        style: placed.style
+      });
+    }
+    for (const cell2 of placed.cells) emitHtmlCell(cell2, pos, renderer, job);
+    emitTableRules(placed, pos, renderer, job);
+    if (placed.border > 0) {
+      emitBorder({ box: placed.box, pos, border: placed.border, color: placed.color, sides: placed.sides, style: placed.style }, renderer, job);
+    }
   }
   if (inAnchor) endHtmlAnchor(renderer, job);
   if (clustersLast && initHtmlAnchor(anchorData, tblBox, renderer, job)) {
@@ -14285,11 +14308,9 @@ function applyPenState(obj, styleAttr, colorAttr, penwidthAttr) {
 function applyNodeStyle(obj, n, job) {
   const styleAttr = nodeAttr(n, n.root, "style");
   const colorAttr = nodeAttr(n, n.root, "color");
-  return withColorScheme(nodeAttr(n, n.root, "colorscheme"), () => {
-    const filled = applyFillState(obj, n, job);
-    applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, "penwidth"));
-    return filled;
-  });
+  const filled = applyFillState(obj, n, job);
+  applyPenState(obj, styleAttr, colorAttr, nodeAttr(n, n.root, "penwidth"));
+  return filled;
 }
 function prepareDrawPoly(poly, filled, obj) {
   if (poly.peripheries !== 0 || !filled) return poly;
@@ -15084,6 +15105,30 @@ var Graph = class {
    * @see lib/cgraph/graph.c:agsubg (attr defval copy)
    */
   graphDefaultsSnapshot;
+  /**
+   * Keys in `attrs` the BUILDER seeded from `graphDefaultsSnapshot` rather than
+   * the input declaring them in this scope (see builder.ts GRAPH_LABEL_INHERIT_
+   * KEYS). cgraph distinguishes these structurally — a seeded value is inherited
+   * through the dict view and has no local symbol, while a local declaration
+   * creates one even when its value equals the inherited value — so the
+   * serializer needs the provenance to decide what write_dict would print.
+   * Undefined on the root graph and on any scope that seeded nothing.
+   * @see lib/cgraph/write.c:262 write_dict
+   */
+  seededAttrs;
+  /**
+   * Graph-attribute keys whose declaration in THIS scope was the first anywhere
+   * in the graph. cgraph's `setattr` splits on exactly this: a key with no
+   * existing symbol takes the global-declaration branch, which ends up seeding
+   * every direct subgraph that already exists with a local empty value (see
+   * `eagerEmptyParts`); a key some earlier scope already declared takes the
+   * "new local definition" branch and touches no subgraph at all. So an
+   * identical `graph [fill=x]` statement makes a child print `fill=""` or print
+   * nothing purely according to whether a SIBLING declared `fill` first.
+   * Undefined on any scope that declared nothing new.
+   * @see lib/cgraph/attr.c:257 setattr (lsym / psym / global branches)
+   */
+  firstGraphDecl;
   /**
    * Layout-engine info; replaces GD_* macros via agbindrec (AD-1).
    * @see lib/cgraph/cgraph.h:agbindrec
@@ -16256,7 +16301,7 @@ function applyLabel(e, g, fi, measurer) {
   const content = isHtml ? htmlValueContent(str) : str;
   e.info.label = makeAnyLabel(content, isHtml, fi, measurer, e);
   g.root.info.has_labels |= EDGE_LABEL;
-  e.info.label_ontop = mapbool2(e.attrs.get("label_float")) ? 1 : 0;
+  e.info.label_ontop = mapbool2(e.attrs.get("labelfloat")) ? 1 : 0;
 }
 function applyXLabel(e, g, fi, measurer) {
   const str = e.attrs.get("xlabel");
@@ -17213,60 +17258,89 @@ function commonInitNodeEdge(g) {
 
 // src/common/ps-fontalias.ts
 var ALIAS_ROWS = [
-  ["AvantGarde-Book", "URW Gothic L", "book", null, null, "sans-Serif"],
-  ["AvantGarde-BookOblique", "URW Gothic L", "book", null, "oblique", "sans-Serif"],
-  ["AvantGarde-Demi", "URW Gothic L", "demi", null, null, "sans-Serif"],
-  ["AvantGarde-DemiOblique", "URW Gothic L", "demi", null, "oblique", "sans-Serif"],
-  ["Bookman-Demi", "URW Bookman L", "demi", null, null, "serif"],
-  ["Bookman-DemiItalic", "URW Bookman L", "demi", null, "italic", "serif"],
-  ["Bookman-Light", "URW Bookman L", "light", null, null, "serif"],
-  ["Bookman-LightItalic", "URW Bookman L", "light", null, "italic", "serif"],
-  ["Courier", "Courier", null, null, null, "monospace"],
-  ["Courier-Bold", "Courier", "bold", null, null, "monospace"],
-  ["Courier-BoldOblique", "Courier", "bold", null, "oblique", "monospace"],
-  ["Courier-Oblique", "Courier", null, null, "oblique", "monospace"],
-  ["Helvetica", "Helvetica", null, null, null, "sans-Serif"],
-  ["Helvetica-Bold", "Helvetica", "bold", null, null, "sans-Serif"],
-  ["Helvetica-BoldOblique", "Helvetica", "bold", null, "oblique", "sans-Serif"],
-  ["Helvetica-Narrow", "Helvetica", null, "condensed", null, "sans-Serif"],
-  ["Helvetica-Narrow-Bold", "Helvetica", "bold", "condensed", null, "sans-Serif"],
-  ["Helvetica-Narrow-BoldOblique", "Helvetica", "bold", "condensed", "oblique", "sans-Serif"],
-  ["Helvetica-Narrow-Oblique", "Helvetica", null, "condensed", "oblique", "sans-Serif"],
-  ["Helvetica-Oblique", "Helvetica", null, null, "oblique", "sans-Serif"],
-  ["NewCenturySchlbk-Bold", "Century Schoolbook L", "bold", null, null, "serif"],
-  ["NewCenturySchlbk-BoldItalic", "Century Schoolbook L", "bold", null, "italic", "serif"],
-  ["NewCenturySchlbk-Italic", "Century Schoolbook L", null, null, "italic", "serif"],
-  ["NewCenturySchlbk-Roman", "Century Schoolbook L", "roman", null, null, "serif"],
-  ["Palatino-Bold", "Palatino Linotype", "bold", null, null, "serif"],
-  ["Palatino-BoldItalic", "Palatino Linotype", "bold", null, "italic", "serif"],
-  ["Palatino-Italic", "Palatino Linotype", null, null, "italic", "serif"],
-  ["Palatino-Roman", "Palatino Linotype", "roman", null, null, "serif"],
-  ["Symbol", "Symbol", null, null, null, "fantasy"],
-  ["Times-Bold", "Times", "bold", null, null, "serif"],
-  ["Times-BoldItalic", "Times", "bold", null, "italic", "serif"],
-  ["Times-Italic", "Times", null, null, "italic", "serif"],
-  ["Times-Roman", "Times", null, null, null, "serif"],
-  ["ZapfChancery-MediumItalic", "URW Chancery L", "medium", null, "italic", "serif"],
-  ["ZapfDingbats", "Dingbats", null, null, null, "fantasy"]
+  ["AvantGarde-Book", "URW Gothic L", "book", null, null, "sans-Serif", null, null],
+  ["AvantGarde-BookOblique", "URW Gothic L", "book", null, "oblique", "sans-Serif", null, "italic"],
+  ["AvantGarde-Demi", "URW Gothic L", "demi", null, null, "sans-Serif", "bold", null],
+  ["AvantGarde-DemiOblique", "URW Gothic L", "demi", null, "oblique", "sans-Serif", "bold", "italic"],
+  ["Bookman-Demi", "URW Bookman L", "demi", null, null, "serif", "bold", null],
+  ["Bookman-DemiItalic", "URW Bookman L", "demi", null, "italic", "serif", "bold", "italic"],
+  ["Bookman-Light", "URW Bookman L", "light", null, null, "serif", null, null],
+  ["Bookman-LightItalic", "URW Bookman L", "light", null, "italic", "serif", null, "italic"],
+  ["Courier", "Courier", null, null, null, "monospace", null, null],
+  ["Courier-Bold", "Courier", "bold", null, null, "monospace", "bold", null],
+  ["Courier-BoldOblique", "Courier", "bold", null, "oblique", "monospace", "bold", "italic"],
+  ["Courier-Oblique", "Courier", null, null, "oblique", "monospace", null, "italic"],
+  ["Helvetica", "Helvetica", null, null, null, "sans-Serif", null, null],
+  ["Helvetica-Bold", "Helvetica", "bold", null, null, "sans-Serif", "bold", null],
+  ["Helvetica-BoldOblique", "Helvetica", "bold", null, "oblique", "sans-Serif", "bold", "italic"],
+  ["Helvetica-Narrow", "Helvetica", null, "condensed", null, "sans-Serif", null, null],
+  ["Helvetica-Narrow-Bold", "Helvetica", "bold", "condensed", null, "sans-Serif", "bold", null],
+  ["Helvetica-Narrow-BoldOblique", "Helvetica", "bold", "condensed", "oblique", "sans-Serif", "bold", "italic"],
+  ["Helvetica-Narrow-Oblique", "Helvetica", null, "condensed", "oblique", "sans-Serif", null, "italic"],
+  ["Helvetica-Oblique", "Helvetica", null, null, "oblique", "sans-Serif", null, "italic"],
+  ["NewCenturySchlbk-Bold", "Century Schoolbook L", "bold", null, null, "serif", "bold", null],
+  ["NewCenturySchlbk-BoldItalic", "Century Schoolbook L", "bold", null, "italic", "serif", "bold", "italic"],
+  ["NewCenturySchlbk-Italic", "Century Schoolbook L", null, null, "italic", "serif", null, "italic"],
+  ["NewCenturySchlbk-Roman", "Century Schoolbook L", "roman", null, null, "serif", null, null],
+  ["Palatino-Bold", "Palatino Linotype", "bold", null, null, "serif", "bold", null],
+  ["Palatino-BoldItalic", "Palatino Linotype", "bold", null, "italic", "serif", "bold", "italic"],
+  ["Palatino-Italic", "Palatino Linotype", null, null, "italic", "serif", null, "italic"],
+  ["Palatino-Roman", "Palatino Linotype", "roman", null, null, "serif", null, null],
+  ["Symbol", "Symbol", null, null, null, "fantasy", null, null],
+  ["Times-Bold", "Times", "bold", null, null, "serif", "bold", null],
+  ["Times-BoldItalic", "Times", "bold", null, "italic", "serif", "bold", "italic"],
+  ["Times-Italic", "Times", null, null, "italic", "serif", null, "italic"],
+  ["Times-Roman", "Times", null, null, null, "serif", null, null],
+  ["ZapfChancery-MediumItalic", "URW Chancery L", "medium", null, "italic", "serif", null, "italic"],
+  ["ZapfDingbats", "Dingbats", null, null, null, "fantasy", null, null]
 ];
 var ALIAS_BY_NAME = new Map(
   ALIAS_ROWS.map((r) => [
     r[0].toLowerCase(),
-    { family: r[1], weight: r[2], stretch: r[3], style: r[4], svgFontFamily: r[5] }
+    {
+      name: r[0],
+      family: r[1],
+      weight: r[2],
+      stretch: r[3],
+      style: r[4],
+      svgFontFamily: r[5],
+      svgFontWeight: r[6],
+      svgFontStyle: r[7]
+    }
   ])
 );
 function translatePostscriptFontname(name) {
   return ALIAS_BY_NAME.get(name.toLowerCase()) ?? null;
 }
-function fontFamilyAttrs(fontName) {
+function fontFamilyAttrs(fontName, mode = FontnameKind.NativeFonts) {
   const a = fontName !== null ? translatePostscriptFontname(fontName) : null;
   if (a === null) return null;
-  const fam = a.svgFontFamily !== a.family ? a.family + "," + a.svgFontFamily : a.family;
+  let family;
+  let weight;
+  let style;
+  switch (mode) {
+    case FontnameKind.PsFonts:
+      family = a.name;
+      weight = a.weight;
+      style = a.style;
+      break;
+    case FontnameKind.SvgFonts:
+      family = a.svgFontFamily;
+      weight = a.svgFontWeight;
+      style = a.svgFontStyle;
+      break;
+    default:
+      family = a.family;
+      weight = a.weight;
+      style = a.style;
+      break;
+  }
+  const fam = a.svgFontFamily !== family ? family + "," + a.svgFontFamily : family;
   let attrs = ' font-family="' + fam + '"';
-  if (a.weight !== null) attrs += ' font-weight="' + a.weight + '"';
+  if (weight !== null) attrs += ' font-weight="' + weight + '"';
   if (a.stretch !== null) attrs += ' font-stretch="' + a.stretch + '"';
-  if (a.style !== null) attrs += ' font-style="' + a.style + '"';
-  return { attrs, weight: a.weight !== null, style: a.style !== null };
+  if (style !== null) attrs += ' font-style="' + style + '"';
+  return { attrs, weight: weight !== null, style: style !== null };
 }
 
 // src/render/svg-gradient.ts
@@ -17911,6 +17985,7 @@ function emitBgcolorBackground(g, bb, bgcolorAttr, job) {
 function svgBeginGraph(g, job) {
   job.devscale = { x: 1, y: -1 };
   job.directed = g.kind === "directed" || g.kind === "strict-directed";
+  job.fontnames = g.info.fontnames ?? FontnameKind.NativeFonts;
   job.drawingId = g.attrs.get("id") ?? "";
   job.write(SVG_XML_DECL);
   const stylesheet = g.attrs.get("stylesheet");
@@ -18200,7 +18275,7 @@ function svgTextspan(pos, span, job) {
   job.write('" y="');
   job.printDouble(y);
   job.write('"');
-  const ff = fontFamilyAttrs(span.fontName);
+  const ff = fontFamilyAttrs(span.fontName, job.fontnames);
   if (ff !== null) job.write(ff.attrs);
   else job.write(' font-family="' + escapeXml(span.fontName ?? "Times,serif") + '"');
   emitFontAttrs(span.fontFlags, job, ff ?? { weight: false, style: false });
@@ -18950,17 +19025,19 @@ function nodeInBox(n, job) {
 function emitNodeBody(n, renderer, job) {
   setHtmlAnchorObj(svgNodeId(n, job), labelTextOf2(n.info.label), job.obj ?? void 0);
   setHtmlObjImgscale(nodeAttr(n, n.root, "imagescale"));
-  renderer.beginNode(n, job);
-  const shape = n.info.shape;
-  if (shape?.fns?.codefn) shape.fns.codefn(job, n);
-  renderNodeXLabel(n, renderer, job);
-  renderer.endNode(n, job);
+  withColorScheme(nodeAttr(n, n.root, "colorscheme"), () => {
+    renderer.beginNode(n, job);
+    const shape = n.info.shape;
+    if (shape?.fns?.codefn) shape.fns.codefn(job, n);
+    renderNodeXLabel(n, renderer, job);
+    renderer.endNode(n, job);
+  });
 }
 function renderNode(n, renderer, job, done) {
   if (done.has(n)) return;
   done.add(n);
   if (!nodeInBox(n, job)) return;
-  const nodeStyle = n.attrs.get("style");
+  const nodeStyle = nodeAttr(n, n.root, "style");
   if (parseStyleFlags(nodeStyle).invis) return;
   if (!isPointNode(n) && styleHasInvisibleAlias(nodeStyle)) return;
   const obj = createObjState(2 /* Node */);
@@ -19583,6 +19660,21 @@ var SplineClipHelper = class _SplineClipHelper {
     }
     return [sflag, eflag];
   }
+  /**
+   * The ORIGINAL edge's arrow end whose TYPE applies at a geometric spline end.
+   *
+   * C resolves both arrow types once from the original edge (arrow_flags) and
+   * encodes each type in its flag, so swapping the two flags when swapEnds is
+   * true carries the type along with it. This port keeps only the presence bit
+   * in the flag and re-reads the type from the `arrowhead`/`arrowtail`
+   * attribute, so the same swap has to be applied to the NAME lookup — without
+   * it a reversed back edge (`C->A [arrowhead=tee]`, head ranked above tail)
+   * draws its `arrowtail` type at the end where C draws the arrowhead.
+   * @see lib/common/splines.c:arrow_clip (if (j) SWAP(sflag, eflag))
+   */
+  static arrowAttrEnd(isTail, j) {
+    return isTail !== j ? "tail" : "head";
+  }
   static resolveArrowFlags(info, hn, fe, orig, j) {
     let [sflag, eflag] = _SplineClipHelper.arrowFlags(orig);
     if (info.splineMerge != null) {
@@ -19623,10 +19715,10 @@ var SplineClipHelper = class _SplineClipHelper {
    * Clip the spline end to the head arrowhead base; records the tip in
    * spl.ep. @see lib/common/arrows.c:arrowEndClip
    */
-  static arrowEndClip(e, ps, startp, endpIn, spl, eflag) {
+  static arrowEndClip(e, ps, startp, endpIn, spl, eflag, attrEnd = "head") {
     let endp = endpIn;
     const elen = arrowClipLength(
-      edgeArrowName(e, "head"),
+      edgeArrowName(e, attrEnd),
       _SplineClipHelper.clipArrowsize(e),
       _SplineClipHelper.clipPenwidth(e)
     );
@@ -19650,10 +19742,10 @@ var SplineClipHelper = class _SplineClipHelper {
    * Clip the spline start to the tail arrowhead base; records the tip
    * in spl.sp. @see lib/common/arrows.c:arrowStartClip
    */
-  static arrowStartClip(e, ps, startpIn, endp, spl, sflag) {
+  static arrowStartClip(e, ps, startpIn, endp, spl, sflag, attrEnd = "tail") {
     let startp = startpIn;
     const slen = arrowClipLength(
-      edgeArrowName(e, "tail"),
+      edgeArrowName(e, attrEnd),
       _SplineClipHelper.clipArrowsize(e),
       _SplineClipHelper.clipPenwidth(e)
     );
@@ -19702,6 +19794,8 @@ var SplineClipHelper = class _SplineClipHelper {
     const [sflag, eflag] = _SplineClipHelper.resolveArrowFlags(info, hn, fe, orig, j);
     newspl.sflag = sflag;
     newspl.eflag = eflag;
+    const startEnd = _SplineClipHelper.arrowAttrEnd(true, j);
+    const endEnd = _SplineClipHelper.arrowAttrEnd(false, j);
     if (info.isOrtho) {
       if (sflag || eflag) {
         _SplineClipHelper.arrowOrthoClip(
@@ -19713,8 +19807,8 @@ var SplineClipHelper = class _SplineClipHelper {
           sflag,
           eflag
         );
-        if (sflag) _SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start], true);
-        if (eflag) _SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3], false);
+        if (sflag) _SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start], true, startEnd);
+        if (eflag) _SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3], false, endEnd);
       }
       return;
     }
@@ -19725,9 +19819,10 @@ var SplineClipHelper = class _SplineClipHelper {
         bounds.start,
         bounds.end,
         newspl,
-        sflag
+        sflag,
+        startEnd
       );
-      _SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start], true);
+      _SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start], true, startEnd);
     }
     if (eflag) {
       bounds.end = _SplineClipHelper.arrowEndClip(
@@ -19736,9 +19831,10 @@ var SplineClipHelper = class _SplineClipHelper {
         bounds.start,
         bounds.end,
         newspl,
-        eflag
+        eflag,
+        endEnd
       );
-      _SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3], false);
+      _SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3], false, endEnd);
     }
   }
   /**
@@ -19837,9 +19933,10 @@ var SplineClipHelper = class _SplineClipHelper {
     }
   }
   /** Record an arrow polygon on the edge for svgArrowPolygons. */
-  static stashArrow(e, tip2, base, isTail) {
+  static stashArrow(e, tip2, base, isTail, attrEnd) {
     const dir = { x: base.x - tip2.x, y: base.y - tip2.y };
-    const ops = arrowDrawOpsForEnd(e, isTail ? "tail" : "head", tip2, dir, _SplineClipHelper.renderPenwidth(e));
+    const end = attrEnd ?? (isTail ? "tail" : "head");
+    const ops = arrowDrawOpsForEnd(e, end, tip2, dir, _SplineClipHelper.renderPenwidth(e));
     if (isTail) e.info.tailArrowOps = ops;
     else e.info.headArrowOps = ops;
   }
@@ -33839,18 +33936,18 @@ function buildSubgraph(root, nodes, name) {
   sg.edges = root.edges.filter((e) => ns.has(e.tail) && ns.has(e.head));
   return sg;
 }
-function ccomps(g, pfx2) {
+function ccomps(g, pfx) {
   const visited = /* @__PURE__ */ new Set();
   const result = [];
   let idx = 0;
   for (const n of g.nodes.values()) {
     if (visited.has(n.name)) continue;
     const comp = dfsCollect(g, n, visited);
-    result.push(buildSubgraph(g, comp, `${pfx2}_${idx++}`));
+    result.push(buildSubgraph(g, comp, `${pfx}_${idx++}`));
   }
   return result;
 }
-function pccomps(g, pfx2) {
+function pccomps(g, pfx) {
   const visited = /* @__PURE__ */ new Set();
   const result = [];
   let idx = 0;
@@ -33862,12 +33959,12 @@ function pccomps(g, pfx2) {
     pinned = true;
   }
   if (pinnedNodes.length > 0) {
-    result.push(buildSubgraph(g, pinnedNodes, `${pfx2}_${idx++}`));
+    result.push(buildSubgraph(g, pinnedNodes, `${pfx}_${idx++}`));
   }
   for (const n of g.nodes.values()) {
     if (visited.has(n.name)) continue;
     const comp = dfsCollect(g, n, visited);
-    result.push(buildSubgraph(g, comp, `${pfx2}_${idx++}`));
+    result.push(buildSubgraph(g, comp, `${pfx}_${idx++}`));
   }
   return { graphs: result, pinned };
 }
@@ -34141,12 +34238,6 @@ function setEdgeTypeFromAttr(g, defaultValue) {
   else et = edgeTypeFromString(s, defaultValue);
   setEdgeType(g, et);
 }
-function getAttrInt(g, key, defaultVal) {
-  const v = g.attrs.get(key);
-  if (v === void 0 || v === "") return defaultVal;
-  const n = parseInt(v, 10);
-  return isNaN(n) ? defaultVal : n;
-}
 function dotPhaseInit(g) {
   dotGraphInit(g);
   setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
@@ -34164,17 +34255,33 @@ function dotPhasePost(g) {
   dotPhasePostNoFinish(g);
   gvPostprocess(g);
 }
+function graphPhase(g) {
+  const v = g.attrs.get("phase");
+  if (v === void 0 || v === "") return -1;
+  const n = parseInt(v, 10);
+  if (isNaN(n) || n > 2147483647) return -1;
+  return n < 1 ? 1 : n;
+}
 function dotLayoutPipeline(g) {
-  const maxphase = getAttrInt(g, "maxphase", -1);
+  const maxphase = graphPhase(g);
   dotPhaseInit(g);
   dotRank(g);
-  if (maxphase === 1) return;
+  if (maxphase === 1) {
+    gvPostprocess(g);
+    return;
+  }
   const rc = dotMincross(g);
   if (rc !== 0) return;
-  if (maxphase === 2) return;
+  if (maxphase === 2) {
+    gvPostprocess(g);
+    return;
+  }
   const posRc = dotPosition(g);
   if (posRc !== 0) return;
-  if (maxphase === 3) return;
+  if (maxphase === 3) {
+    gvPostprocess(g);
+    return;
+  }
   dotPhasePost(g);
 }
 var CL_OFFSET2 = 8;
@@ -40762,6 +40869,11 @@ function tuneControl(g, ctrl) {
   ctrl.beautifyLeaves = mapBool(aggetGraph(g, "beautify"), false);
   ctrl.doShrinking = mapBool(aggetGraph(g, "overlap_shrink"), true);
   ctrl.rotation = lateDouble(aggetGraph(g, "rotation"), 0, -Number.MAX_VALUE);
+  if (ctrl.rotation !== 0) {
+    throw new Error(
+      `sfdp rotation="${ctrl.rotation}": rotate() is not ported (unreachable at sfdp defaults); see plans/port-catalog/README.md`
+    );
+  }
   ctrl.edgeLabelingScheme = lateInt(aggetGraph(g, "label_scheme"), 0, 0);
   if (ctrl.edgeLabelingScheme > 4) ctrl.edgeLabelingScheme = 0;
 }
@@ -46197,256 +46309,461 @@ function taper(bez, radfunc, initwid) {
   return emitStroke(pp);
 }
 
-// src/render/dot.ts
-var XDOT_VERSION = "1.7";
-var MAX_NEGNUM = 1e15;
-var NEAR_ZERO = 5e-3;
-var NUM_XBUFS = 8;
-var NON_LINE_STYLES = /* @__PURE__ */ new Set([
-  "filled",
-  "bold",
-  "rounded",
-  "diagonals",
-  "striped",
-  "wedged",
-  "invis",
-  "invisible",
-  "radial"
-]);
-function trimAndStrip(s) {
-  const dot = s.indexOf(".");
-  if (dot < 0) return s;
-  let end = s.length;
-  while (end > dot + 1 && s[end - 1] === "0") end--;
-  if (s[end - 1] === ".") end--;
-  const t = s.slice(0, end);
-  if (t.startsWith("0.")) return t.slice(1);
-  if (t.startsWith("-0.")) return "-" + t.slice(2);
-  return t;
-}
-function printNum(n) {
-  if (Math.abs(n) > MAX_NEGNUM) {
-    return n < 0 ? String(-MAX_NEGNUM) : String(MAX_NEGNUM);
+// src/render/map.ts
+var DQ = '"';
+function exactDecimalDigits2(v) {
+  const dv = new DataView(new ArrayBuffer(8));
+  dv.setFloat64(0, Math.abs(v));
+  const bits = dv.getBigUint64(0);
+  const expBits = Number(bits >> 52n & 0x7ffn);
+  const mant = bits & 0xfffffffffffffn;
+  const m = expBits === 0 ? mant : mant | 1n << 52n;
+  const e = (expBits === 0 ? 1 : expBits) - 1075;
+  let intDigits;
+  let fracLen = 0;
+  if (e >= 0) {
+    intDigits = (m << BigInt(e)).toString();
+  } else {
+    intDigits = (m * 5n ** BigInt(-e)).toString();
+    fracLen = -e;
   }
-  if (Math.abs(n) < NEAR_ZERO) return "0";
-  return trimAndStrip(n.toFixed(3));
-}
-function makeXbufs() {
-  const bufs = Array.from({ length: NUM_XBUFS + 4 }, () => []);
-  bufs[8 /* NDraw */] = bufs[1 /* CDraw */];
-  bufs[9 /* EDraw */] = bufs[1 /* CDraw */];
-  bufs[10 /* NLabel */] = bufs[5 /* CLabel */];
-  bufs[11 /* ELabel */] = bufs[5 /* CLabel */];
-  return bufs;
-}
-function xdotNum(v) {
-  let s = toFixed2HalfEven(v);
-  if (s.indexOf(".") >= 0) {
-    let end = s.length;
-    while (end > 0 && s[end - 1] === "0") end--;
-    if (s[end - 1] === ".") end--;
-    s = s.slice(0, end);
+  if (intDigits.length <= fracLen) {
+    intDigits = "0".repeat(fracLen - intDigits.length + 1) + intDigits;
   }
-  return s === "-0" ? "0" : s;
-}
-function xdotPoint(p) {
-  return xdotNum(p.x) + " " + xdotNum(p.y) + " ";
-}
-function xdotPoints(c, pts) {
-  let s = c + " " + String(pts.length) + " ";
-  for (const p of pts) s += xdotPoint(p);
-  return s;
+  const pointPos = intDigits.length - fracLen;
+  const firstSig = intDigits.search(/[1-9]/);
+  return { digits: intDigits.slice(firstSig), exp10: pointPos - firstSig - 1 };
 }
-function utf8Len(s) {
-  let n = 0;
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    if (c < 128) n += 1;
-    else if (c < 2048) n += 2;
-    else if (c >= 55296 && c <= 56319) {
-      n += 4;
-      i++;
-    } else n += 3;
+function printG5(v) {
+  if (v === 0 || !Number.isFinite(v)) return String(v);
+  const P = 5;
+  const { digits, exp10 } = exactDecimalDigits2(v);
+  let sig = digits.slice(0, P);
+  if (sig.length < P) sig += "0".repeat(P - sig.length);
+  const rest = digits.slice(P);
+  const restNonzeroAfterFirst = /[1-9]/.test(rest.slice(1));
+  const roundUp = rest.length > 0 && (rest[0] > "5" || rest[0] === "5" && restNonzeroAfterFirst || rest[0] === "5" && !restNonzeroAfterFirst && (sig.charCodeAt(P - 1) - 48) % 2 === 1);
+  let exp = exp10;
+  if (roundUp) {
+    const n = String(BigInt(sig) + 1n);
+    sig = n.length > P ? (exp++, n.slice(0, P)) : n;
   }
-  return n;
-}
-function chanByte(v) {
-  return Math.round(Math.max(0, Math.min(1, v)) * 255);
-}
-function gvColorRgba(c) {
-  if (c.type === "rgba") return [chanByte(c.r), chanByte(c.g), chanByte(c.b), chanByte(c.a)];
-  if (c.type === "none") return [255, 255, 254, 0];
-  const out = { type: "rgba", r: 0, g: 0, b: 0, a: 0 };
-  colorxlate(c.type === "string" ? c.s : "", out, "rgba");
-  return out.type === "rgba" ? [chanByte(out.r), chanByte(out.g), chanByte(out.b), chanByte(out.a)] : [0, 0, 0, 255];
-}
-function xdotColorBody(rgba) {
-  const hx = (n) => n.toString(16).padStart(2, "0");
-  const body = "#" + hx(rgba[0]) + hx(rgba[1]) + hx(rgba[2]);
-  return rgba[3] === 255 ? "7 -" + body : "9 -" + body + hx(rgba[3]);
+  const sign2 = v < 0 ? "-" : "";
+  if (exp < -4 || exp >= P) {
+    const mant = (sig[0] + "." + sig.slice(1)).replace(/\.?0+$/, "");
+    const as = Math.abs(exp);
+    return sign2 + mant + "e" + (exp < 0 ? "-" : "+") + (as < 10 ? "0" : "") + String(as);
+  }
+  let s;
+  if (exp >= sig.length - 1) {
+    s = sig + "0".repeat(exp - sig.length + 1);
+  } else if (exp >= 0) {
+    s = sig.slice(0, exp + 1) + "." + sig.slice(exp + 1);
+  } else {
+    s = "0." + "0".repeat(-exp - 1) + sig;
+  }
+  if (s.includes(".")) s = s.replace(/\.?0+$/, "");
+  return sign2 + s;
 }
-function xdotColorOp(prefix, rgba) {
-  return prefix + xdotColorBody(rgba) + " ";
+function plainCoord(v) {
+  return printG5(v / 72);
 }
-function linearGradientOp(pts, fillColor, stopColor, frac, angleDeg) {
-  const { g0, g1 } = getGradientPoints(pts, angleDeg * Math.PI / 180, false, true);
-  const inner = "[" + xdotNum(g0.x) + " " + xdotNum(g0.y) + " " + xdotNum(g1.x) + " " + xdotNum(g1.y) + " 2 " + gradientStops(fillColor, stopColor, frac) + "]";
-  return "C " + String(utf8Len(inner)) + " -" + inner + " ";
+var CANON_KEYWORDS = ["node", "edge", "strict", "graph", "digraph", "subgraph"];
+var MAX_OUTPUTLINE = 128;
+function isDigitByte(b) {
+  return b >= 48 && b <= 57;
 }
-function gradientStops(fillColor, stopColor, frac) {
-  const fill = gvColorRgba(fillColor);
-  const stop = gvColorRgba(stopColor);
-  const stops = frac > 0 ? [[frac, fill], [frac, stop]] : [[0, fill], [1, stop]];
-  return stops.map(([f, c]) => trimFixed3(f) + " " + xdotColorBody(c)).join(" ");
+function isAlnumByte(b) {
+  return isDigitByte(b) || b >= 65 && b <= 90 || b >= 97 && b <= 122;
 }
-function radialGradientOp(pts, fillColor, stopColor, frac, angleDeg) {
-  const rad2 = angleDeg * Math.PI / 180;
-  const gp = getGradientPoints(pts, rad2, true, true);
-  const cx = gp.g0.x;
-  const cy = gp.g0.y;
-  const r1 = gp.g1.x;
-  const r2 = gp.g1.y;
-  const c1x = angleDeg === 0 ? cx : cx + r1 * Math.cos(rad2);
-  const c1y = angleDeg === 0 ? cy : cy + r1 * Math.sin(rad2);
-  const inner = "(" + xdotNum(c1x) + " " + xdotNum(c1y) + " " + xdotNum(r1) + " " + xdotNum(cx) + " " + xdotNum(cy) + " " + xdotNum(r2) + " 2 " + gradientStops(fillColor, stopColor, frac) + ")";
-  return "C " + String(utf8Len(inner)) + " -" + inner + " ";
+function isIdCharByte(b) {
+  return isAlnumByte(b) || b === 46 || b === 45 || b >= 128;
 }
-function xdotPenColor(c) {
-  return xdotColorOp("c ", gvColorRgba(c));
+function isEscapeAt(bytes, i) {
+  if (bytes[i] !== 92) return false;
+  const c = bytes[i + 1];
+  return c !== void 0 && 'EGHLNTlnr\\"'.includes(String.fromCharCode(c));
 }
-function xdotFillColor(c) {
-  return xdotColorOp("C ", gvColorRgba(c));
+function agstrcanon(arg) {
+  if (isHtmlValue(arg)) return "<" + htmlValueContent(arg) + ">";
+  return agstrcanonText(arg);
 }
-function xdotFont(size, name) {
-  return "F " + xdotNum(size > 0 ? size : 0) + " " + String(utf8Len(name)) + " -" + name + " ";
+function agstrcanonText(arg) {
+  if (arg.length === 0) return '""';
+  const bytes = new TextEncoder().encode(arg);
+  const out = [34];
+  let needsQuotes = false;
+  let partOfEscape = false;
+  let backslashPending = false;
+  let cnt = 0;
+  let dotcnt = 0;
+  let maybeNum = isDigitByte(bytes[0]) || bytes[0] === 46 || bytes[0] === 45;
+  for (let i = 0; i < bytes.length; i++) {
+    const uc = bytes[i];
+    if (uc === 34 && !partOfEscape) {
+      out.push(92);
+      needsQuotes = true;
+    } else if (!partOfEscape && isEscapeAt(bytes, i)) {
+      needsQuotes = true;
+      partOfEscape = true;
+    } else if (maybeNum) {
+      if (uc === 45) {
+        if (cnt) {
+          maybeNum = false;
+          needsQuotes = true;
+        }
+      } else if (uc === 46) {
+        if (dotcnt++) {
+          maybeNum = false;
+          needsQuotes = true;
+        }
+      } else if (!isDigitByte(uc)) {
+        maybeNum = false;
+        needsQuotes = true;
+      }
+      partOfEscape = false;
+    } else if (!(isAlnumByte(uc) || uc === 95 || uc >= 128)) {
+      needsQuotes = true;
+      partOfEscape = false;
+    } else {
+      partOfEscape = false;
+    }
+    out.push(uc);
+    cnt++;
+    const next = bytes[i + 1];
+    if (next !== void 0) {
+      const last = out[out.length - 1];
+      const canBreak = !(isIdCharByte(last) || last === 92) && isIdCharByte(next);
+      if (backslashPending && canBreak) {
+        out.push(92, 10);
+        needsQuotes = true;
+        backslashPending = false;
+        cnt = 0;
+      } else if (cnt >= MAX_OUTPUTLINE) {
+        if (canBreak) {
+          out.push(92, 10);
+          needsQuotes = true;
+          cnt = 0;
+        } else {
+          backslashPending = true;
+        }
+      }
+    }
+  }
+  out.push(34);
+  const first = bytes[0];
+  if (needsQuotes || cnt === 1 && (first === 46 || first === 45)) {
+    return new TextDecoder().decode(new Uint8Array(out));
+  }
+  const lower = arg.toLowerCase();
+  for (const tok of CANON_KEYWORDS) {
+    if (tok === lower) return new TextDecoder().decode(new Uint8Array(out));
+  }
+  return arg;
 }
-function xdotStrOp(prefix, s) {
-  return prefix + String(utf8Len(s)) + " -" + s + " ";
+function lateNN(v, def) {
+  return v !== void 0 && v !== "" ? v : def;
 }
-function xdotId(s) {
-  if (/^[A-Za-z_][A-Za-z_0-9]*$/.test(s)) return s;
-  if (/^-?(\.[0-9]+|[0-9]+(\.[0-9]*)?)$/.test(s)) return s;
-  return '"' + s.replace(/"/g, '\\"') + '"';
+function plainNodeFill(n, g) {
+  const fillcolor = lateNN(nodeAttr(n, g, "fillcolor"), "");
+  if (fillcolor !== "") return fillcolor;
+  return lateNN(nodeAttr(n, g, "color"), "lightgrey");
 }
-function gfmt5(v) {
-  if (!Number.isFinite(v)) return String(v);
-  if (v === 0) return "0";
-  let s = printfSig(v, 5);
-  const e = s.indexOf("e");
-  if (e >= 0) {
-    let mant = s.slice(0, e);
-    if (mant.indexOf(".") >= 0) mant = mant.replace(/0+$/, "").replace(/\.$/, "");
-    const ei = parseInt(s.slice(e + 1), 10);
-    return mant + "e" + (ei < 0 ? "-" : "+") + String(Math.abs(ei)).padStart(2, "0");
+function plainNodeLabel(n, g) {
+  const lbl = n.info.label;
+  const attr2 = nodeAttr(n, g, "label");
+  if (lbl !== void 0 && lbl.u.kind === "html") {
+    const a = attr2 ?? "";
+    return "<" + (isHtmlValue(a) ? htmlValueContent(a) : a) + ">";
   }
-  if (s.indexOf(".") >= 0) s = s.replace(/0+$/, "").replace(/\.$/, "");
-  return s;
-}
-function gfmt2(v) {
-  return printfFixed(v, 2);
+  if (attr2 !== void 0 && isHtmlValue(attr2) && lbl !== void 0 && lbl.u.kind === "txt") {
+    return agstrcanonText(htmlValueContent(attr2));
+  }
+  const shape = n.info.shape;
+  if (shape !== void 0 && shape.kind === 2 /* SH_RECORD */) {
+    return agstrcanonText(nodeAttr(n, g, "label") ?? "\\N");
+  }
+  const text = lbl !== void 0 ? lbl.text : n.attrs.get("label") ?? n.name;
+  return agstrcanonText(text);
 }
-function lpStr(p) {
-  return gfmt5(p.x) + "," + gfmt5(p.y);
+function plainNodeAttrs(n, g) {
+  const shapeAttr = lateNN(nodeAttr(n, g, "shape"), "ellipse");
+  const shapefile = nodeAttr(n, g, "shapefile");
+  const shapeName = shapefile !== void 0 && shapefile !== "" && shapeAttr !== "epsf" ? "custom" : shapeAttr;
+  return {
+    label: plainNodeLabel(n, g),
+    style: lateNN(nodeAttr(n, g, "style"), "solid"),
+    shape: shapeName,
+    color: lateNN(nodeAttr(n, g, "color"), "black"),
+    fill: plainNodeFill(n, g)
+  };
 }
-function edgeAttrsAttached(e) {
-  return e.info.edge_type !== IGNORED && e.info.spl != null;
+function writePlainNode(n, g, out) {
+  const x = plainCoord(n.info.coord.x);
+  const y = plainCoord(n.info.coord.y);
+  const w = printG5(n.info.width);
+  const h = printG5(n.info.height);
+  const a = plainNodeAttrs(n, g);
+  out.push("node " + agstrcanonText(n.name) + " " + x + " " + y + " " + w + " " + h + " " + a.label + " " + a.style + " " + a.shape + " " + a.color + " " + a.fill + "\n");
 }
-function appendRecordRects(n, f, out) {
-  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)
-    );
+function collectSplinePts(e) {
+  if (!e.info.spl) return [];
+  const pts = [];
+  for (const bz of e.info.spl.list) {
+    for (let i = 0; i < bz.size; i++) pts.push(bz.list[i]);
   }
-  for (let i = 0; i < f.n_flds; i++) appendRecordRects(n, f.fld[i], out);
+  return pts;
 }
-function echoAttr(attrs, key) {
-  const v = attrs.get(key);
-  if (v === void 0 || v.length === 0) return [];
-  return [key + '="' + agcanonEscape(v) + '"'];
+function writeNodeAndPort(n, portname, out) {
+  let name = n.name;
+  if (n.info.clustnode) {
+    const i = name.indexOf(":");
+    if (i >= 0) name = name.slice(i + 1);
+  }
+  out.push(" " + agstrcanonText(name));
+  if (portname !== "") out.push(":" + agstrcanonText(portname));
 }
-function pfx(parts) {
-  return parts.length === 0 ? "" : " " + parts.join(" ");
+function writePlainEdgeHead(e, tport, hport, pts, out) {
+  out.push("edge");
+  writeNodeAndPort(e.tail, tport, out);
+  writeNodeAndPort(e.head, hport, out);
+  out.push(" " + String(pts.length));
+  for (const pt of pts) {
+    out.push(" " + plainCoord(pt.x) + " " + plainCoord(pt.y));
+  }
 }
-function graphLabelAttrs(g) {
-  const label = g.info.label;
-  if (!label || label.text.length === 0) {
-    return [
-      ...echoAttr(g.attrs, "lp"),
-      ...echoAttr(g.attrs, "lwidth"),
-      ...echoAttr(g.attrs, "lheight")
-    ];
+function writePlainEdge(e, extend, out) {
+  const tport = extend ? e.attrs.get("tailport") ?? "" : "";
+  const hport = extend ? e.attrs.get("headport") ?? "" : "";
+  const pts = collectSplinePts(e);
+  if (pts.length > 0) writePlainEdgeHead(e, tport, hport, pts, out);
+  const lbl = e.info.label;
+  if (lbl !== void 0) {
+    out.push(" " + agstrcanonText(lbl.text) + " " + plainCoord(lbl.pos.x) + " " + plainCoord(lbl.pos.y));
   }
-  return [
-    'lp="' + lpStr(label.pos) + '"',
-    "lwidth=" + gfmt2(label.dimen.x / POINTS_PER_INCH),
-    "lheight=" + gfmt2(label.dimen.y / POINTS_PER_INCH)
-  ];
+  const style = lateNN(e.attrs.get("style"), "solid");
+  const color = lateNN(e.attrs.get("color"), "black");
+  out.push(" " + style + " " + color + "\n");
 }
-function formatNodeAttrs(n) {
-  const info = n.info;
-  const x = printNum(info.coord.x);
-  const y = printNum(info.coord.y);
-  const w = printNum(info.width);
-  const h = printNum(info.height);
-  const parts = [`pos="${x},${y}"`, `width=${w}`, `height=${h}`];
-  n.attrs.forEach((v, k) => {
-    if (k !== "pos" && k !== "width" && k !== "height") {
-      parts.push(`${k}="${v}"`);
+function writePlain(g, job, extend) {
+  const w = plainCoord(g.info.bb.ur.x);
+  const h = plainCoord(g.info.bb.ur.y);
+  const zoom = initJobViewportZoom(
+    job.bb,
+    parseDrawingSize(g.attrs.get("size")),
+    { x: 0, y: 0 }
+  );
+  job.write("graph " + printG5(zoom) + " " + w + " " + h + "\n");
+  const nodes = nodesInSeq(g);
+  for (const n of nodes) {
+    if (n.info.clustnode) continue;
+    const buf = [];
+    writePlainNode(n, g, buf);
+    job.write(buf.join(""));
+  }
+  for (const n of nodes) {
+    for (const e of n.outEdges(g)) {
+      const buf = [];
+      writePlainEdge(e, extend, buf);
+      job.write(buf.join(""));
     }
-  });
-  return parts.join(" ");
-}
-function formatEdgePos(e) {
-  const spl = e.info.spl;
-  if (!spl || spl.list.length === 0) return "";
-  if (e.info.edge_type === IGNORED) return "";
-  const parts = [];
-  for (const bez of spl.list) {
-    if (bez.sflag) parts.push("s," + gfmt5(bez.sp.x) + "," + gfmt5(bez.sp.y));
-    if (bez.eflag) parts.push("e," + gfmt5(bez.ep.x) + "," + gfmt5(bez.ep.y));
-    const pts = bez.list.slice(0, bez.size);
-    for (const p of pts) parts.push(gfmt5(p.x) + "," + gfmt5(p.y));
   }
-  return 'pos="' + parts.join(" ") + '"';
-}
-function edgeConnector(directed) {
-  return directed ? "->" : "--";
+  job.write("stop\n");
 }
-function isDirected(g) {
-  return g.kind === "directed" || g.kind === "strict-directed";
+function cmapxObjAnchor(obj) {
+  return {
+    url: obj.url ?? "",
+    tooltip: obj.tooltip ?? "",
+    target: obj.target ?? "",
+    id: obj.id ?? ""
+  };
 }
-function dotBeginGraphHeader(g, job) {
-  const kw = isDirected(g) ? "digraph" : "graph";
-  job.write(kw + " " + g.name + " {\n");
-  const bb = g.info.bb;
-  const bbStr = printNum(bb.ll.x) + "," + printNum(bb.ll.y) + "," + printNum(bb.ur.x) + "," + printNum(bb.ur.y);
-  job.write('	graph [bb="' + bbStr + '"];\n');
+function writeCmapxGraphShape(job, out) {
+  const obj = job.obj;
+  if (!obj || !obj.urlMapPts.length) return;
+  mapOutputCmapx(obj.urlMapShape, obj.urlMapPts, cmapxObjAnchor(obj), true, out);
 }
-var DotRenderer = class {
-  type = "dot";
-  /** @see plugin/core/gvplugin_core.c registration table */
+function cmapxShape(shape) {
+  if (shape === 1 /* Circle */) return "circle";
+  if (shape === 0 /* Rectangle */) return "rect";
+  return "poly";
+}
+function cmapxCoordsRect(pts) {
+  return String(Math.round(pts[0].x)) + "," + String(Math.round(pts[1].y)) + "," + String(Math.round(pts[1].x)) + "," + String(Math.round(pts[0].y));
+}
+function cmapxCoordsCircle(pts) {
+  const cx = Math.round(pts[0].x);
+  const cy = Math.round(pts[0].y);
+  const r = Math.round(pts[1].x - pts[0].x);
+  return String(cx) + "," + String(cy) + "," + String(r);
+}
+function cmapxCoordsPoly(pts) {
+  return pts.map((p) => String(Math.round(p.x)) + "," + String(Math.round(p.y))).join(",");
+}
+function cmapxCoords(shape, pts) {
+  if (shape === 1 /* Circle */) return cmapxCoordsCircle(pts);
+  if (shape === 0 /* Rectangle */) return cmapxCoordsRect(pts);
+  return cmapxCoordsPoly(pts);
+}
+function mapCmapxAttrs(a, out) {
+  if (a.id) out.push(" id=" + DQ + escapeXml(a.id) + DQ);
+  if (a.url) out.push(" href=" + DQ + escapeXml(a.url) + DQ);
+  if (a.target) out.push(" target=" + DQ + escapeXmlTitle(a.target) + DQ);
+  if (a.tooltip) out.push(" title=" + DQ + escapeXmlTitle(a.tooltip) + DQ);
+}
+function mapOutputCmapx(shape, pts, a, isXml, out) {
+  out.push("<area shape=" + DQ + cmapxShape(shape) + DQ);
+  mapCmapxAttrs(a, out);
+  out.push(" alt=" + DQ + DQ);
+  out.push(" coords=" + DQ + cmapxCoords(shape, pts) + DQ);
+  out.push(isXml ? "/>\n" : ">\n");
+}
+function mapOutputImap(shape, pts, url, out) {
+  if (!url) return;
+  if (shape === 0 /* Rectangle */) {
+    out.push("rect " + url + " " + Math.round(pts[0].x) + "," + Math.round(pts[1].y) + " " + Math.round(pts[1].x) + "," + Math.round(pts[0].y) + "\n");
+  } else if (shape === 1 /* Circle */) {
+    const r = Math.round(pts[1].x - pts[0].x);
+    out.push("circle " + url + " " + Math.round(pts[0].x) + "," + Math.round(pts[0].y) + "," + String(r) + "\n");
+  } else {
+    const pairs = pts.map((p) => Math.round(p.x) + "," + Math.round(p.y)).join(" ");
+    out.push("poly " + url + " " + pairs + "\n");
+  }
+}
+var PlainRenderer = class {
+  type = "plain";
   quality = 0;
-  beginGraph(g, job) {
-    dotBeginGraphHeader(g, job);
+  beginGraph(_g, _job) {
   }
-  endGraph(_g, job) {
-    job.write("}\n");
+  endGraph(g, job) {
+    writePlain(g, job, false);
+  }
+  beginNode(_n, _job) {
+  }
+  endNode(_n, _job) {
+  }
+  beginEdge(_e, _job) {
+  }
+  endEdge(_e, _job) {
+  }
+  textspan(_pos, _span, _job) {
+  }
+  ellipse(_c, _rx, _ry, _f, _j) {
+  }
+  polygon(_pts, _filled, _job) {
+  }
+  bezier(_pts, _filled, _job) {
+  }
+  polyline(_pts, _job) {
+  }
+};
+var PlainExtRenderer = class {
+  type = "plain-ext";
+  quality = 0;
+  beginGraph(_g, _job) {
+  }
+  endGraph(g, job) {
+    writePlain(g, job, true);
   }
   beginNode(_n, _job) {
   }
-  endNode(n, job) {
-    const attrs = formatNodeAttrs(n);
-    job.write("	" + n.name + " [" + attrs + "];\n");
+  endNode(_n, _job) {
   }
   beginEdge(_e, _job) {
   }
+  endEdge(_e, _job) {
+  }
+  textspan(_pos, _span, _job) {
+  }
+  ellipse(_c, _rx, _ry, _f, _j) {
+  }
+  polygon(_pts, _filled, _job) {
+  }
+  bezier(_pts, _filled, _job) {
+  }
+  polyline(_pts, _job) {
+  }
+};
+function mapGraphName(g) {
+  return g.anonymous ? "%1" : g.name;
+}
+function graphAttr2(g, key) {
+  for (let s = g; s !== null; s = s.parent) {
+    const v = s.attrs.get(key);
+    if (v !== void 0 && v !== "") return v;
+  }
+  return void 0;
+}
+function graphMapUrl(g) {
+  const raw = graphAttr2(g, "href") ?? graphAttr2(g, "URL");
+  return raw === void 0 ? null : substObjAnchor(raw, g);
+}
+function buildMapCtx(g, job, mapPolygon) {
+  const drawingDpi = lateDouble(g.attrs.get("dpi"), lateDouble(g.attrs.get("resolution"), 0, 0), 0);
+  const mapDpi = drawingDpi > 0 ? drawingDpi : 96;
+  const devscale = mapDpi / POINTS_PER_INCH;
+  const z = initJobViewportZoom(job.bb, parseDrawingSize(g.attrs.get("size")), job.pad);
+  const marginOff = { x: job.margin.x * devscale, y: job.margin.y * devscale };
+  return { bb: job.bb, pad: job.pad, scale: z * devscale, marginOff, mapPolygon };
+}
+function anchorOf(url, tooltip, target, id) {
+  return { url: url ?? "", tooltip: tooltip ?? "", target: target ?? "", id: id ?? "" };
+}
+var MapRendererBase = class {
+  quality = 0;
+  mapCtx = null;
+  beginGraph(g, job) {
+    job.flags |= EMIT_CLUSTERS_LAST;
+    this.mapCtx = buildMapCtx(g, job, this.mapPolygon);
+    if (this.isCmapx) {
+      const name = escapeXml(mapGraphName(g));
+      job.write("<map id=" + DQ + name + DQ + " name=" + DQ + name + DQ + ">\n");
+      return;
+    }
+    job.write("base referer\n");
+    const url = graphMapUrl(g);
+    if (url) job.write("default " + url + "\n");
+  }
+  endGraph(_g, job) {
+    if (!this.isCmapx) return;
+    const obj = job.obj;
+    if (obj !== null && this.mapCtx !== null && (obj.url !== null || obj.explicitTooltip)) {
+      computeGraphUrlMap(obj, this.mapCtx);
+    }
+    const buf = [];
+    writeCmapxGraphShape(job, buf);
+    job.write(buf.join(""));
+    job.write("</map>\n");
+  }
+  beginNode(n, job) {
+    if (this.mapCtx !== null && job.obj !== null) computeNodeUrlMap(n, job.obj, this.mapCtx);
+  }
+  beginCluster(sg, job) {
+    const bb = sg.info.bb;
+    if (this.mapCtx !== null && job.obj !== null && bb !== void 0) {
+      computeClusterUrlMap(bb, job.obj, this.mapCtx);
+    }
+  }
   endEdge(e, job) {
-    const directed = isDirected(e.tail.root);
-    const conn = edgeConnector(directed);
-    const posAttr = formatEdgePos(e);
-    const attrList = posAttr ? " [" + posAttr + "]" : "";
-    job.write("	" + e.tail.name + " " + conn + " " + e.head.name + attrList + ";\n");
+    if (this.mapCtx !== null && job.obj !== null) this.emitEdge(e, job.obj, job);
+  }
+  /** C emit_map_rect: record the HTML table/cell box as the pending hot spot,
+   *  so the following beginAnchor emits its <area>. @see emit.c:640 */
+  emitMapRect(box, job) {
+    if (this.mapCtx !== null && job.obj !== null) {
+      computeClusterUrlMap(box, job.obj, this.mapCtx);
+    }
+  }
+  beginAnchor(url, tip2, target, id, job) {
+    const obj = job.obj;
+    if (obj === null || obj.urlMapPts.length === 0) return;
+    this.emitShape(obj.urlMapShape, obj.urlMapPts, { url, tooltip: tip2, target, id }, job);
+  }
+  endNode(_n, _job) {
+  }
+  beginEdge(_e, _job) {
+  }
+  endCluster(_sg, _job) {
   }
   textspan(_pos, _span, _job) {
   }
@@ -46458,7 +46775,247 @@ var DotRenderer = class {
   }
   polyline(_pts, _job) {
   }
+  /** Emit one hot spot: `<area>` (cmapx) or a plain `keyword url coords` line. */
+  emitShape(shape, pts, a, job) {
+    const buf = [];
+    if (this.isCmapx) mapOutputCmapx(shape, pts, a, true, buf);
+    else mapOutputImap(shape, pts, a.url, buf);
+    job.write(buf.join(""));
+  }
+  /** Whole-edge spline outline(s) then center/head/tail label hot spots.
+   * @see lib/common/emit.c:emit_begin_edge (2851-2872) / emit_end_edge */
+  emitEdge(e, obj, job) {
+    const spl = e.info.spl;
+    const wholeEdge = obj.url !== null || obj.explicitTooltip;
+    if (spl !== void 0 && this.mapPolygon && wholeEdge) {
+      const w2 = Math.max(obj.penWidth / 2, 2);
+      const anchor = anchorOf(obj.url, obj.tooltip, obj.target, obj.id);
+      for (const poly of computeEdgeSplineMaps(spl, w2, this.mapCtx)) {
+        this.emitShape(2 /* Polygon */, poly, anchor, job);
+      }
+    }
+    const centerA = {
+      url: obj.labelUrl,
+      tooltip: obj.labelTooltip,
+      target: obj.labelTarget,
+      explicit: obj.explicitLabelTooltip
+    };
+    this.emitEdgeLabel(e.info.label, centerA, obj, job);
+    this.emitEdgeLabel(e.info.xlabel, centerA, obj, job);
+    this.emitEdgeLabel(
+      e.info.head_label,
+      { url: obj.headUrl, tooltip: obj.headTooltip, target: obj.headTarget, explicit: obj.explicitHeadTooltip },
+      obj,
+      job
+    );
+    this.emitEdgeLabel(
+      e.info.tail_label,
+      { url: obj.tailUrl, tooltip: obj.tailTooltip, target: obj.tailTarget, explicit: obj.explicitTailTooltip },
+      obj,
+      job
+    );
+  }
+  /** One edge label hot spot (map_label rect), if placed and url/explicit-tip.
+   * @see lib/common/emit.c:emit_edge_label */
+  emitEdgeLabel(lab, la, obj, job) {
+    const placed = lab !== void 0 && lab.set && this.mapCtx !== null;
+    if (!placed || la.url === null && !la.explicit) return;
+    computeLabelRectMap(lab, obj, this.mapCtx);
+    this.emitShape(0 /* Rectangle */, obj.urlMapPts, anchorOf(la.url, la.tooltip, la.target, obj.id), job);
+  }
+};
+var ImapRenderer = class extends MapRendererBase {
+  type = "imap";
+  isCmapx = false;
+  mapPolygon = true;
+};
+var ImapNpRenderer = class extends MapRendererBase {
+  type = "imap-np";
+  isCmapx = false;
+  mapPolygon = false;
+};
+var CmapxRenderer = class extends MapRendererBase {
+  type = "cmapx";
+  isCmapx = true;
+  mapPolygon = true;
+};
+var CmapxNpRenderer = class extends MapRendererBase {
+  type = "cmapx-np";
+  isCmapx = true;
+  mapPolygon = false;
 };
+function createPlainRenderer() {
+  return new PlainRenderer();
+}
+function createPlainExtRenderer() {
+  return new PlainExtRenderer();
+}
+function createImapRenderer() {
+  return new ImapRenderer();
+}
+function createImapNpRenderer() {
+  return new ImapNpRenderer();
+}
+function createCmapxRenderer() {
+  return new CmapxRenderer();
+}
+function createCmapxNpRenderer() {
+  return new CmapxNpRenderer();
+}
+
+// src/render/dot/xdot-ops.ts
+var XDOT_VERSION = "1.7";
+var MAX_NEGNUM = 1e15;
+var NEAR_ZERO = 5e-3;
+var NUM_XBUFS = 8;
+var NON_LINE_STYLES = /* @__PURE__ */ new Set([
+  "filled",
+  "bold",
+  "rounded",
+  "diagonals",
+  "striped",
+  "wedged",
+  "invis",
+  "invisible",
+  "radial"
+]);
+function trimAndStrip(s) {
+  const dot = s.indexOf(".");
+  if (dot < 0) return s;
+  let end = s.length;
+  while (end > dot + 1 && s[end - 1] === "0") end--;
+  if (s[end - 1] === ".") end--;
+  const t = s.slice(0, end);
+  if (t.startsWith("0.")) return t.slice(1);
+  if (t.startsWith("-0.")) return "-" + t.slice(2);
+  return t;
+}
+function printNum(n) {
+  if (Math.abs(n) > MAX_NEGNUM) {
+    return n < 0 ? String(-MAX_NEGNUM) : String(MAX_NEGNUM);
+  }
+  if (Math.abs(n) < NEAR_ZERO) return "0";
+  return trimAndStrip(n.toFixed(3));
+}
+function makeXbufs() {
+  const bufs = Array.from({ length: NUM_XBUFS + 4 }, () => []);
+  bufs[8 /* NDraw */] = bufs[1 /* CDraw */];
+  bufs[9 /* EDraw */] = bufs[1 /* CDraw */];
+  bufs[10 /* NLabel */] = bufs[5 /* CLabel */];
+  bufs[11 /* ELabel */] = bufs[5 /* CLabel */];
+  return bufs;
+}
+function xdotNum(v) {
+  let s = toFixed2HalfEven(v);
+  if (s.indexOf(".") >= 0) {
+    let end = s.length;
+    while (end > 0 && s[end - 1] === "0") end--;
+    if (s[end - 1] === ".") end--;
+    s = s.slice(0, end);
+  }
+  return s === "-0" ? "0" : s;
+}
+function xdotPoint(p) {
+  return xdotNum(p.x) + " " + xdotNum(p.y) + " ";
+}
+function xdotPoints(c, pts) {
+  let s = c + " " + String(pts.length) + " ";
+  for (const p of pts) s += xdotPoint(p);
+  return s;
+}
+function utf8Len(s) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) n += 1;
+    else if (c < 2048) n += 2;
+    else if (c >= 55296 && c <= 56319) {
+      n += 4;
+      i++;
+    } else n += 3;
+  }
+  return n;
+}
+function chanByte(v) {
+  return Math.round(Math.max(0, Math.min(1, v)) * 255);
+}
+function gvColorRgba(c) {
+  if (c.type === "rgba") return [chanByte(c.r), chanByte(c.g), chanByte(c.b), chanByte(c.a)];
+  if (c.type === "none") return [255, 255, 254, 0];
+  const out = { type: "rgba", r: 0, g: 0, b: 0, a: 0 };
+  colorxlate(c.type === "string" ? c.s : "", out, "rgba");
+  return out.type === "rgba" ? [chanByte(out.r), chanByte(out.g), chanByte(out.b), chanByte(out.a)] : [0, 0, 0, 255];
+}
+function xdotColorBody(rgba) {
+  const hx = (n) => n.toString(16).padStart(2, "0");
+  const body = "#" + hx(rgba[0]) + hx(rgba[1]) + hx(rgba[2]);
+  return rgba[3] === 255 ? "7 -" + body : "9 -" + body + hx(rgba[3]);
+}
+function xdotColorOp(prefix, rgba) {
+  return prefix + xdotColorBody(rgba) + " ";
+}
+function linearGradientOp(pts, fillColor, stopColor, frac, angleDeg) {
+  const { g0, g1 } = getGradientPoints(pts, angleDeg * Math.PI / 180, false, true);
+  const inner = "[" + xdotNum(g0.x) + " " + xdotNum(g0.y) + " " + xdotNum(g1.x) + " " + xdotNum(g1.y) + " 2 " + gradientStops(fillColor, stopColor, frac) + "]";
+  return "C " + String(utf8Len(inner)) + " -" + inner + " ";
+}
+function gradientStops(fillColor, stopColor, frac) {
+  const fill = gvColorRgba(fillColor);
+  const stop = gvColorRgba(stopColor);
+  const stops = frac > 0 ? [[frac, fill], [frac, stop]] : [[0, fill], [1, stop]];
+  return stops.map(([f, c]) => trimFixed3(f) + " " + xdotColorBody(c)).join(" ");
+}
+function radialGradientOp(pts, fillColor, stopColor, frac, angleDeg) {
+  const rad2 = angleDeg * Math.PI / 180;
+  const gp = getGradientPoints(pts, rad2, true, true);
+  const cx = gp.g0.x;
+  const cy = gp.g0.y;
+  const r1 = gp.g1.x;
+  const r2 = gp.g1.y;
+  const c1x = angleDeg === 0 ? cx : cx + r1 * Math.cos(rad2);
+  const c1y = angleDeg === 0 ? cy : cy + r1 * Math.sin(rad2);
+  const inner = "(" + xdotNum(c1x) + " " + xdotNum(c1y) + " " + xdotNum(r1) + " " + xdotNum(cx) + " " + xdotNum(cy) + " " + xdotNum(r2) + " 2 " + gradientStops(fillColor, stopColor, frac) + ")";
+  return "C " + String(utf8Len(inner)) + " -" + inner + " ";
+}
+function xdotPenColor(c) {
+  return xdotColorOp("c ", gvColorRgba(c));
+}
+function xdotFillColor(c) {
+  return xdotColorOp("C ", gvColorRgba(c));
+}
+function xdotFont(size, name) {
+  return "F " + xdotNum(size > 0 ? size : 0) + " " + String(utf8Len(name)) + " -" + name + " ";
+}
+function xdotStrOp(prefix, s) {
+  return prefix + String(utf8Len(s)) + " -" + s + " ";
+}
+function xdotId(s) {
+  if (/^[A-Za-z_][A-Za-z_0-9]*$/.test(s)) return s;
+  if (/^-?(\.[0-9]+|[0-9]+(\.[0-9]*)?)$/.test(s)) return s;
+  const body = s.replace(/"/g, '\\"');
+  const trailingBackslashes = /\\*$/.exec(body)[0].length;
+  return '"' + body + (trailingBackslashes % 2 === 1 ? "\\" : "") + '"';
+}
+function gfmt5(v) {
+  if (!Number.isFinite(v)) return String(v);
+  if (v === 0) return "0";
+  let s = printfSig(v, 5);
+  const e = s.indexOf("e");
+  if (e >= 0) {
+    let mant = s.slice(0, e);
+    if (mant.indexOf(".") >= 0) mant = mant.replace(/0+$/, "").replace(/\.$/, "");
+    const ei = parseInt(s.slice(e + 1), 10);
+    return mant + "e" + (ei < 0 ? "-" : "+") + String(Math.abs(ei)).padStart(2, "0");
+  }
+  if (s.indexOf(".") >= 0) s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return s;
+}
+function gfmt2(v) {
+  return printfFixed(v, 2);
+}
+function lpStr(p) {
+  return gfmt5(p.x) + "," + gfmt5(p.y);
+}
 function escBackslash(s) {
   return s.replace(/\\/g, "\\\\");
 }
@@ -46491,27 +47048,741 @@ function trimFixed3(v) {
   if (s[end - 1] === ".") end--;
   return s.slice(0, end);
 }
-var XdotRenderer = class {
+
+// src/render/dot/attrs.ts
+function edgeAttrsAttached(e) {
+  return e.info.edge_type !== IGNORED && e.info.spl != null;
+}
+function appendRecordRects(n, f, out) {
+  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);
+}
+var COMPUTED_NODE_ATTRS = /* @__PURE__ */ new Set(["pos", "width", "height", "xlp", "rects", "_draw_", "_ldraw_"]);
+var COMPUTED_EDGE_ATTRS = /* @__PURE__ */ new Set([
+  "pos",
+  "lp",
+  "xlp",
+  "head_lp",
+  "tail_lp",
+  "tailport",
+  "headport",
+  "_draw_",
+  "_ldraw_",
+  "_hdraw_",
+  "_tdraw_",
+  "_hldraw_",
+  "_tldraw_"
+]);
+var NODENAME_ESC = "\\N";
+function effectiveEdgeDefaults(scope) {
+  const eff = /* @__PURE__ */ new Map();
+  for (let g = scope; g !== null; g = g.parent) {
+    for (const [k, v] of g.edgeDefaults) if (!eff.has(k)) eff.set(k, v);
+  }
+  return eff;
+}
+function effectiveNodeDefaults(scope) {
+  const eff = /* @__PURE__ */ new Map();
+  for (let g = 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;
+}
+function nodeRecord(n) {
+  const rec = new Map(n.nodeDefaultsSnapshot ?? []);
+  if (!rec.has("label")) rec.set("label", NODENAME_ESC);
+  for (const [k, v] of n.attrs) rec.set(k, v);
+  return rec;
+}
+function objInputParts(record, defaults, computed) {
+  const parts = [];
+  for (const k of /* @__PURE__ */ 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;
+}
+function computedPart(key, raw, defaults) {
+  if (defaults !== void 0 && defaults.get(key) === raw) return [];
+  return [key + "=" + agstrcanon(raw)];
+}
+var COMPUTED_GRAPH_ATTRS = /* @__PURE__ */ new Set([
+  "_draw_",
+  "_ldraw_",
+  "bb",
+  "lp",
+  "lwidth",
+  "lheight"
+]);
+var COMPUTED_GRAPH_ATTRS_XDOT = /* @__PURE__ */ new Set([...COMPUTED_GRAPH_ATTRS, "xdotversion"]);
+function computedGraphAttrs(emitDraws) {
+  return emitDraws ? COMPUTED_GRAPH_ATTRS_XDOT : COMPUTED_GRAPH_ATTRS;
+}
+function graphInputParts(g, top, emitDraws) {
+  const computed = computedGraphAttrs(emitDraws);
+  const parts = [];
+  const snap = g.graphDefaultsSnapshot;
+  const seeded = g.seededAttrs;
+  for (const [k, v] of g.attrs) {
+    if (computed.has(k)) continue;
+    if (!top && seeded !== void 0 && seeded.has(k)) continue;
+    if (writeDictSkips(v, snap?.get(k))) continue;
+    parts.push(k + "=" + agstrcanon(v));
+  }
+  if (!top && snap !== void 0) parts.push(...eagerEmptyParts(g, snap, computed));
+  return parts;
+}
+function eagerEmptyParts(g, snap, computed) {
+  const parts = [];
+  const p = g.parent;
+  if (p === null) return parts;
+  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;
+}
+function dictParts(defaults) {
+  const parts = [];
+  for (const [k, v] of defaults) parts.push(k + "=" + agstrcanon(v));
+  return parts;
+}
+function nodeDictParts(g, top) {
+  const defs = new Map(g.nodeDefaults);
+  if (top && !defs.has("label")) defs.set("label", NODENAME_ESC);
+  return dictParts(defs);
+}
+function echoAttr(attrs, key) {
+  const v = attrs.get(key);
+  if (v === void 0 || v.length === 0) return [];
+  return [key + '="' + agcanonEscape(v) + '"'];
+}
+function writeDictSkips(v, inherited) {
+  return v.length === 0 && inherited === "";
+}
+function echoGraphAttr(g, key) {
+  const v = g.attrs.get(key);
+  if (v === void 0) return [];
+  if (writeDictSkips(v, g.graphDefaultsSnapshot?.get(key))) return [];
+  return [key + '="' + agcanonEscape(v) + '"'];
+}
+function graphLabelAttrs(g) {
+  const label = g.info.label;
+  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)
+  ];
+}
+function edgePosRaw(e) {
+  const spl = e.info.spl;
+  if (!spl || spl.list.length === 0) return null;
+  if (e.info.edge_type === IGNORED) return null;
+  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;
+}
+function edgeConnector(directed) {
+  return directed ? "->" : "--";
+}
+function isDirected(g) {
+  return g.kind === "directed" || g.kind === "strict-directed";
+}
+
+// src/render/dot/agwrite.ts
+var DotWriterBase = class {
+  /** Clusters in render order (GD_clust); filled by the renderer's endCluster. */
+  clusters = [];
+  /**
+   * 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)
+   */
+  drawAttr(key, value) {
+    return key + '="' + agcanonEscape(value) + '"';
+  }
+  /** `llx,lly,urx,ury` from a graph's layout bb. */
+  bbStr(g) {
+    const bb = g.info.bb;
+    return gfmt5(bb.ll.x) + "," + gfmt5(bb.ll.y) + "," + gfmt5(bb.ur.x) + "," + gfmt5(bb.ur.y);
+  }
+  /**
+   * 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
+   */
+  serialize(g) {
+    const ctx = {
+      out: [],
+      preorder: /* @__PURE__ */ new Map(),
+      nodeLW: /* @__PURE__ */ new Map(),
+      edgeLW: /* @__PURE__ */ new Map(),
+      attrsWritten: /* @__PURE__ */ new Set(),
+      level: 0
+    };
+    this.subgdfs(g, 1, ctx.preorder);
+    this.writeHdr(g, true, ctx);
+    this.writeBody(g, ctx);
+    this.writeTrl(ctx);
+    return ctx.out.join("");
+  }
+  /** Preorder-number the subgraph tree. @see write.c:subgdfs */
+  subgdfs(g, ix, preorder) {
+    let ix0 = ix;
+    preorder.set(g, ix0);
+    for (const sub of g.subgraphs.values()) ix0 = this.subgdfs(sub, ix0, preorder);
+    return ix0 + 1;
+  }
+  /** A subgraph is anonymous when its name is empty or a `%N` local name. */
+  isAnonymous(g) {
+    return g.name.length === 0 || g.name.charCodeAt(0) === 37;
+  }
+  /** 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 */
+  hasBb(g) {
+    return g === g.root || this.clusters.includes(g);
+  }
+  /** 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 */
+  irrelevantSubgraph(g) {
+    if (!this.isAnonymous(g)) return false;
+    if (this.clusters.includes(g)) return false;
+    if (g.nodeDefaults.size > 0 || g.edgeDefaults.size > 0) return false;
+    if (g.parent) {
+      if (this.hasBb(g) !== this.hasBb(g.parent)) return false;
+      for (const [k, v] of g.attrs) {
+        if (g.parent.attrs.get(k) !== v) return false;
+      }
+    } else if (g.attrs.size > 0) {
+      return false;
+    }
+    return true;
+  }
+  /** 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 */
+  subgGraphAttrs(sg) {
+    const parts = [];
+    parts.push(...echoGraphAttr(sg, "bb"));
+    parts.push(...graphLabelAttrs(sg));
+    parts.push(...graphInputParts(sg, false, this.emitDraws));
+    return parts;
+  }
+  indent(ctx) {
+    return "	".repeat(ctx.level);
+  }
+  /** @see write.c:write_hdr */
+  writeHdr(g, top, ctx) {
+    if (top) {
+      const strict = g.kind === "strict-directed" || g.kind === "strict-undirected" ? "strict " : "";
+      const kw = isDirected(g) ? "digraph" : "graph";
+      const nm = g.name.length > 0 && !this.isAnonymous(g) ? xdotId(g.name) + " " : "";
+      ctx.out.push(strict + kw + " " + nm + "{\n");
+      ctx.level++;
+    } else {
+      const nm = this.isAnonymous(g) ? "" : "subgraph " + xdotId(g.name) + " ";
+      ctx.out.push(this.indent(ctx) + nm + "{\n");
+      ctx.level++;
+    }
+    this.writeDicts(g, top, ctx);
+  }
+  /**
+   * Emit this scope's `graph` / `node` / `edge` default statements, in that
+   * order. @see lib/cgraph/write.c:307 write_dicts
+   */
+  writeDicts(g, top, ctx) {
+    const graphParts = top ? this.graphAttrs(g) : this.clusters.includes(g) ? this.clusterAttrs(g) : this.subgGraphAttrs(g);
+    this.writeDict("graph", graphParts, ctx);
+    this.writeDict("node", nodeDictParts(g, top), ctx);
+    this.writeDict("edge", dictParts(g.edgeDefaults), ctx);
+  }
+  /**
+   * One `<name> [...]` default statement. Entries are emitted in **strcmp order
+   * of attribute name**: cgraph's attribute dicts are `Dttree`s keyed on
+   * `Agsym_t.name` with a NULL comparf (attr.c:34), so `dtfirst`/`dtnext` walk
+   * them sorted — the oracle's `graph [bb, rankdir]` and `[height, pos, width]`.
+   *
+   * Layout mirrors write_dict exactly: a single entry stays on one line, and two
+   * or more break after each `,` with the body indented one level deeper and the
+   * closing `];` back at the statement's own level.
+   *
+   * Not ported: the `EMPTY(defval) && !sym->print` skip (write.c:271-280). Every
+   * entry here was explicitly declared or computed, i.e. `print` is set, so that
+   * branch is unreachable until the eager-propagation artifact lands — an
+   * `agapply`-installed empty default is the only `print == false` producer.
+   *
+   * @see lib/cgraph/write.c:262 write_dict
+   */
+  writeDict(name, parts, ctx) {
+    if (parts.length === 0) return;
+    const sorted = [...parts].sort((a, b) => {
+      const ka = a.slice(0, a.indexOf("="));
+      const kb = b.slice(0, b.indexOf("="));
+      return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+    ctx.out.push(this.indent(ctx) + name + " [");
+    ctx.level++;
+    ctx.out.push(sorted.join(",\n" + this.indent(ctx)));
+    ctx.level--;
+    if (sorted.length > 1) ctx.out.push("\n" + this.indent(ctx));
+    ctx.out.push("];\n");
+  }
+  /**
+   * One object's `[...]` attribute block, or '' when it has no attributes.
+   * Entries sort strcmp like every dict (attr.c:34). Layout is
+   * write_nondefault_attrs, which differs from write_dict in two ways: the block
+   * opens with a literal TAB before `[`, and the closing `]` follows the last
+   * value directly — there is no newline+indent before it.
+   * @see lib/cgraph/write.c:471 write_nondefault_attrs
+   */
+  objAttrBlock(parts, ctx) {
+    if (parts.length === 0) return "";
+    const sorted = [...parts].sort((a, b) => {
+      const ka = a.slice(0, a.indexOf("="));
+      const kb = b.slice(0, b.indexOf("="));
+      return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+    ctx.level++;
+    const body = sorted.join(",\n" + this.indent(ctx));
+    ctx.level--;
+    return "	[" + body + "]";
+  }
+  /** @see write.c:write_trl */
+  writeTrl(ctx) {
+    ctx.level--;
+    ctx.out.push(this.indent(ctx) + "}\n");
+  }
+  /** @see write.c:write_subgs */
+  writeSubgs(g, ctx) {
+    for (const sub of g.subgraphs.values()) {
+      if (this.irrelevantSubgraph(sub)) {
+        this.writeSubgs(sub, ctx);
+      } else {
+        this.writeHdr(sub, false, ctx);
+        this.writeBody(sub, ctx);
+        this.writeTrl(ctx);
+      }
+    }
+  }
+  /** @see write.c:write_body — subgraphs, then this scope's nodes and edges. */
+  writeBody(g, ctx) {
+    this.writeSubgs(g, ctx);
+    for (const n of nodesInSeq(g)) {
+      if (this.writeNodeTest(g, n, ctx)) this.writeNode(g, n, ctx);
+      let prev = n;
+      for (const e of n.outEdges(g)) {
+        if (prev !== e.head && this.writeNodeTest(g, e.head, ctx)) {
+          this.writeNode(g, e.head, ctx);
+          prev = e.head;
+        }
+        if (this.writeEdgeTest(g, e, ctx)) this.writeEdge(g, e, ctx);
+      }
+    }
+  }
+  /** @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 */
+  writeNodeTest(g, n, ctx) {
+    if (n.info.clustnode) return false;
+    return (ctx.nodeLW.get(n) ?? 0) < ctx.preorder.get(g);
+  }
+  /** 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 */
+  emitNodeName(n) {
+    if (n.info.clustnode) {
+      const i = n.name.indexOf(":");
+      if (i >= 0) return n.name.slice(i + 1);
+    }
+    return n.name;
+  }
+  /** @see write.c:write_edge_test */
+  writeEdgeTest(g, e, ctx) {
+    return (ctx.edgeLW.get(e) ?? 0) < ctx.preorder.get(g);
+  }
+  /** @see write.c:write_node */
+  writeNode(g, n, ctx) {
+    let s = this.indent(ctx) + xdotId(this.emitNodeName(n));
+    if (!ctx.attrsWritten.has(n)) {
+      s += this.objAttrBlock(this.nodeAttrs(n, g), ctx);
+      ctx.attrsWritten.add(n);
+    }
+    ctx.out.push(s + ";\n");
+    ctx.nodeLW.set(n, ctx.preorder.get(g));
+  }
+  /** @see write.c:write_edge — attrs only on first emission, bare thereafter. */
+  /**
+   * The `:port` / `:port:compass` suffix C writes after an endpoint name.
+   *
+   * These are NOT ordinary attributes on the way out: write_nondefault_attrs
+   * skips the tailport/headport symbols (write.c:487-492) precisely because
+   * this function re-emits them as endpoint syntax, so an edge parsed from
+   * `A:f0:ne -> B` round-trips through the port syntax rather than through a
+   * `tailport="f0:ne"` attribute.
+   *
+   * C reads the value with agxget, which falls back to the edge dict default,
+   * and gates on the SYMBOL existing at all — both are subsumed here by the
+   * attr-then-default lookup coming back undefined. An html-like value is
+   * canonicalized whole; a plain one splits on its FIRST `:` (strchr) so the
+   * port and the compass point are canonicalized separately.
+   * @see lib/cgraph/write.c:565 write_port
+   */
+  portSuffix(e, g, key) {
+    const val2 = e.attrs.get(key) ?? effectiveEdgeDefaults(g).get(key);
+    if (val2 === void 0 || val2.length === 0) return "";
+    if (isHtmlValue(val2)) return ":" + agstrcanon(val2);
+    const i = val2.indexOf(":");
+    if (i < 0) return ":" + agstrcanonText(val2);
+    return ":" + agstrcanonText(val2.slice(0, i)) + ":" + agstrcanonText(val2.slice(i + 1));
+  }
+  writeEdge(g, e, ctx) {
+    const conn = edgeConnector(isDirected(g));
+    let s = this.indent(ctx) + xdotId(this.emitNodeName(e.tail)) + this.portSuffix(e, g, "tailport") + " " + conn + " " + xdotId(this.emitNodeName(e.head)) + this.portSuffix(e, g, "headport");
+    if (!ctx.attrsWritten.has(e)) {
+      s += this.objAttrBlock(this.edgeAttrStr(e, g), ctx);
+      ctx.attrsWritten.add(e);
+    }
+    ctx.out.push(s + ";\n");
+    ctx.edgeLW.set(e, ctx.preorder.get(g));
+  }
+  /** Root-graph attribute block: `_draw_`, `_ldraw_`, `bb`, `xdotversion`. */
+  graphAttrs(g) {
+    const d = this.drawsOf(g);
+    const parts = [];
+    if (d?.draw) parts.push(this.drawAttr("_draw_", d.draw));
+    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
+    parts.push('bb="' + this.bbStr(g) + '"');
+    parts.push(...graphLabelAttrs(g));
+    if (this.emitDraws) parts.push("xdotversion=" + agstrcanon(XDOT_VERSION));
+    parts.push(...graphInputParts(g, true, this.emitDraws));
+    return parts;
+  }
+  /** 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 */
+  clusterAttrs(sg) {
+    const d = this.drawsOf(sg);
+    const parts = this.emitDraws ? [this.drawAttr("_draw_", d?.draw ?? "")] : [];
+    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
+    if (sg.info.bb) parts.push('bb="' + this.bbStr(sg) + '"');
+    parts.push(...graphLabelAttrs(sg));
+    parts.push(...graphInputParts(sg, false, this.emitDraws));
+    return parts;
+  }
+  /** Node attribute block: pos/width/height plus `_draw_`/`_ldraw_`. `scope` is
+   *  the subgraph the node is being WRITTEN in, whose node dict every value is
+   *  compared against. @see lib/cgraph/write.c:537-545 write_node */
+  nodeAttrs(n, scope) {
+    const info = n.info;
+    const defs = effectiveNodeDefaults(scope);
+    const posRaw = gfmt5(info.coord.x) + "," + gfmt5(info.coord.y);
+    const widthRaw = gfmt5((info.lw + info.rw) / 72);
+    const heightRaw = gfmt5(info.ht / 72);
+    const parts = [
+      ...computedPart("pos", posRaw, defs),
+      ...computedPart("width", widthRaw, defs),
+      ...computedPart("height", heightRaw, defs)
+    ];
+    parts.push(...this.nodeXlpPart(n, defs));
+    parts.push(...this.nodeRectsPart(n, defs));
+    const d = this.drawsOf(n);
+    if (d?.draw) parts.push(this.drawAttr("_draw_", d.draw));
+    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
+    parts.push(...objInputParts(nodeRecord(n), defs, COMPUTED_NODE_ATTRS));
+    return parts;
+  }
+  /** The `[...]` attribute body for an edge (draw ops + spline `pos`), or ''. */
+  edgeAttrStr(e, g) {
+    const defs = effectiveEdgeDefaults(g);
+    const parts = this.edgeDrawParts(e);
+    const posRaw = edgePosRaw(e);
+    if (posRaw !== null) {
+      parts.push(...computedPart("pos", posRaw, defs));
+    } else {
+      parts.push(...echoAttr(e.attrs, "pos"));
+    }
+    parts.push(...this.edgeLabelPosParts(e, defs));
+    parts.push(...objInputParts(e.attrs, defs, COMPUTED_EDGE_ATTRS));
+    return parts;
+  }
+  /** `xlp` — only when the node HAS an xlabel AND the xlabel placer actually set
+   *  its position (`ND_xlabel(n)->set`). An xlabel that was never placed is
+   *  omitted entirely, so an input `xlp` survives and is echoed.
+   *  @see lib/common/output.c:309-313 */
+  nodeXlpPart(n, defs) {
+    const xlabel = n.info.xlabel;
+    if (!xlabel || !xlabel.set) return echoAttr(n.attrs, "xlp");
+    const raw = lpStr(xlabel.pos);
+    return computedPart("xlp", raw, defs);
+  }
+  /** `rects` — record field boxes. C gates on the SHAPE NAME being exactly
+   *  "record" (`strcmp(ND_shape(n)->name, "record") == 0`), so `Mrecord` and
+   *  HTML-table nodes get NO rects; confirmed against the native oracle. When
+   *  the shape is not a record the input's `rects` is never overwritten and is
+   *  echoed — patchwork forces every node to `box`, so a re-fed dot output
+   *  returns its old record rects untouched. @see lib/common/output.c:314-317 */
+  nodeRectsPart(n, defs) {
+    const shape = n.info.shape;
+    if (shape?.name !== "record") return echoAttr(n.attrs, "rects");
+    const rects = [];
+    appendRecordRects(n, n.info.shape_info, rects);
+    const raw = rects.join(" ");
+    return computedPart("rects", raw, defs);
+  }
+  /** The six `_draw_`-family attributes of an edge, in C's order. */
+  edgeDrawParts(e) {
+    const d = this.drawsOf(e);
+    const parts = [];
+    if (d?.draw) parts.push(this.drawAttr("_draw_", d.draw));
+    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
+    if (d?.hdraw) parts.push(this.drawAttr("_hdraw_", d.hdraw));
+    if (d?.tdraw) parts.push(this.drawAttr("_tdraw_", d.tdraw));
+    if (d?.hldraw) parts.push(this.drawAttr("_hldraw_", d.hldraw));
+    if (d?.tldraw) parts.push(this.drawAttr("_tldraw_", d.tldraw));
+    return parts;
+  }
+  /**
+   * `lp`/`xlp`/`head_lp`/`tail_lp` for one edge, in C's order.
+   *
+   * Note the asymmetry C encodes: `lp`/`head_lp`/`tail_lp` are emitted whenever
+   * the label EXISTS, but `xlp` additionally requires `->set` — an unplaced
+   * xlabel is omitted. Each gate is independent, and each FAILED gate leaves the
+   * input's own value in the slot for write.c to echo: an unrouted edge
+   * (patchwork routes none) returns the `lp` a previous dot run wrote.
+   * @see lib/common/output.c:377-396
+   */
+  edgeLabelPosParts(e, defs) {
+    const attached = edgeAttrsAttached(e);
+    const info = e.info;
+    const parts = [];
+    const lpPart = (key, label) => {
+      const raw = lpStr(label.pos);
+      return computedPart(key, raw, defs);
+    };
+    if (attached && info.label) parts.push(...lpPart("lp", info.label));
+    else parts.push(...echoAttr(e.attrs, "lp"));
+    if (attached && info.xlabel && info.xlabel.set) {
+      parts.push(...lpPart("xlp", info.xlabel));
+    } else parts.push(...echoAttr(e.attrs, "xlp"));
+    if (attached && info.head_label) {
+      parts.push(...lpPart("head_lp", info.head_label));
+    } else parts.push(...echoAttr(e.attrs, "head_lp"));
+    if (attached && info.tail_label) {
+      parts.push(...lpPart("tail_lp", info.tail_label));
+    } else parts.push(...echoAttr(e.attrs, "tail_lp"));
+    return parts;
+  }
+};
+
+// src/render/dot/edge-draw.ts
+var DEFAULT_COLOR5 = "black";
+function emitArrowOp(buf, op, pen) {
+  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;
+  }
+}
+var EdgeDrawBase = class extends DotWriterBase {
+  /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
+  penwidth = new Array(12).fill(1);
+  /**
+   * 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
+   */
+  emitPlainSpline(e, list, edraw, job) {
+    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);
+      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. */
+  emitSplineBezier(bez, radius, edraw, job) {
+    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));
+  }
+  emitTaperedSpline(e, bz, edraw, job) {
+    if (bz === void 0) 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
+   */
+  emitSplitSpline(bzList, colorAttr, edraw, job) {
+    const segs = parseSegs(colorAttr).segs;
+    const firstColor = segs[0]?.color ?? DEFAULT_COLOR5;
+    let endColor = firstColor;
+    for (const bz of bzList) {
+      if (bz === void 0 || 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
+   */
+  emitParallelSpline(bzList, colorAttr, numc, edraw, job) {
+    const segData = bzList.map(
+      (bz) => bz !== void 0 && bz.size >= 4 ? buildOffsetLists(bz.list, (2 + numc) / 2) : { offlist: [], tmplist: [] }
+    );
+    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? DEFAULT_COLOR5);
+    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));
+      }
+    }
+    return {
+      headColor: colors[0] ?? DEFAULT_COLOR5,
+      tailColor: colors[1] ?? colors[0] ?? DEFAULT_COLOR5
+    };
+  }
+  /** 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 */
+  emitArrows(buf, ops, job, state3, penOverride) {
+    if (ops === void 0) return;
+    const pen = penOverride !== void 0 ? 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[state3]) >= 5e-4) {
+        this.penwidth[state3] = pw;
+        buf.push(xdotStrOp("S ", "setlinewidth(" + trimFixed3(pw) + ")"));
+      }
+      buf.push(xdotStrOp("S ", "solid"));
+      buf.push(xdotPenColor(pen));
+      emitArrowOp(buf, op, pen);
+    }
+  }
+};
+
+// src/render/dot.ts
+var XdotRenderer = class extends EdgeDrawBase {
   type = "xdot";
   /** @see plugin/core/gvplugin_core.c registration table */
   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
+   */
+  emitDraws = true;
+  /** 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. */
+  drawsOf(obj) {
+    return this.emitDraws ? this.draws.get(obj) : void 0;
+  }
   /** Per-render draw buffers. Indices 8/9 alias 1; 10/11 alias 5. */
   bufs = makeXbufs();
-  /** setlinewidth state per emit_state. @see gvrender_core_dot.c penwidth[] */
-  penwidth = new Array(12).fill(1);
   /** text-flag state per emit_state. @see gvrender_core_dot.c textflags[] */
   textflags = new Array(12).fill(0);
   /** Accumulated draw strings keyed by model object (C: agset on the object). */
   draws = /* @__PURE__ */ new Map();
-  /** 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. */
-  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) */
   edgeDrawable = true;
-  beginGraph(g, _job) {
+  beginGraph(_g, _job) {
     this.bufs = makeXbufs();
     this.penwidth = new Array(12).fill(1);
     this.textflags = new Array(12).fill(0);
@@ -46529,7 +47800,7 @@ var XdotRenderer = class {
   endGraph(g, job) {
     const gd = this.flush(0 /* GDraw */);
     const gl = this.flush(4 /* GLabel */);
-    if (gd || gl) {
+    if (this.emitDraws && (gd || gl)) {
       const set = this.drawsFor(g);
       if (gd) set.draw = gd;
       if (gl) set.ldraw = escBackslash(gl);
@@ -46553,19 +47824,25 @@ var XdotRenderer = class {
     ];
     const buf = this.bufs[0 /* GDraw */];
     buf.push(xdotPenColor(resolveRenderColor("transparent")));
-    const stop = fillSpec.includes(":") ? findStopColor(fillSpec) : null;
-    if (stop !== null) {
-      const angle = Number(g.attrs.get("gradientangle") ?? 0) || 0;
-      const radial = parseStyleFlags(g.attrs.get("style")).radial;
-      const op = radial ? radialGradientOp : linearGradientOp;
-      buf.push(
-        op(corners, resolveRenderColor(stop.fillColor), resolveRenderColor(stop.stopColor), stop.frac, angle)
-      );
-    } else {
-      buf.push(xdotFillColor(resolveRenderColor(fillSpec)));
-    }
+    buf.push(this.backgroundFillOp(g, fillSpec, corners));
     buf.push(xdotPoints("P", corners));
   }
+  /** 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 */
+  backgroundFillOp(g, fillSpec, corners) {
+    const stop = fillSpec.includes(":") ? findStopColor(fillSpec) : null;
+    if (stop === null) return xdotFillColor(resolveRenderColor(fillSpec));
+    const angle = Number(g.attrs.get("gradientangle") ?? 0) || 0;
+    const op = parseStyleFlags(g.attrs.get("style")).radial ? radialGradientOp : linearGradientOp;
+    return op(
+      corners,
+      resolveRenderColor(stop.fillColor),
+      resolveRenderColor(stop.stopColor),
+      stop.frac,
+      angle
+    );
+  }
   beginNode(_n, _job) {
   }
   endNode(n, _job) {
@@ -46604,25 +47881,17 @@ var XdotRenderer = class {
     } else if (edgeIsTapered(e)) {
       this.emitTaperedSpline(e, spl.list[0], edraw, job);
     } else if (numc > 0) {
-      this.emitParallelSpline(spl.list, colorAttr, numc, edraw, job);
+      const c = this.emitParallelSpline(
+        spl.list,
+        colorAttr,
+        numc,
+        edraw,
+        job
+      );
+      tailArrowColor = c.tailColor;
+      headArrowColor = c.headColor;
     } else {
-      const radius = orthoRoundedRadius(e, job);
-      const obj = job.obj;
-      const origStyle = obj !== null ? [...obj.rawStyle] : [];
-      const multi = spl.list.length > 1;
-      for (const bez of spl.list) {
-        const pts = bez.list.slice(0, bez.size);
-        const polys = radius !== null && bez.size >= 4 ? orthoRoundedPolylines(pts, radius) : [];
-        if (polys.length > 0) {
-          for (const poly of polys) edraw.push(this.styleOp(job), this.penOp(job), xdotPoints("L", poly));
-        } else {
-          edraw.push(this.styleOp(job), this.penOp(job), xdotPoints("B", pts));
-        }
-        if (obj !== null && multi && (bez.sflag || bez.eflag)) {
-          obj.rawStyle = origStyle.length > 0 ? origStyle : ["solid"];
-        }
-      }
-      if (obj !== null) obj.rawStyle = origStyle;
+      this.emitPlainSpline(e, spl.list, edraw, job);
     }
     this.emitArrows(this.bufs[2 /* TDraw */], e.info.tailArrowOps, job, 2 /* TDraw */, tailArrowColor);
     this.emitArrows(this.bufs[3 /* HDraw */], e.info.headArrowOps, job, 3 /* HDraw */, headArrowColor);
@@ -46632,121 +47901,43 @@ var XdotRenderer = class {
    * -tapered` (the style), a transparent pen, the edge-color fill, then the
    * polygon vertices from `taper()` (y-up). @see lib/common/emit.c:2422
    */
-  emitTaperedSpline(e, bz, edraw, job) {
-    if (bz === void 0) 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
-   */
-  emitSplitSpline(bzList, colorAttr, edraw, job) {
-    const segs = parseSegs(colorAttr).segs;
-    const firstColor = segs[0]?.color ?? "black";
-    let endColor = firstColor;
-    for (const bz of bzList) {
-      if (bz === void 0 || 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
-   */
-  emitParallelSpline(bzList, colorAttr, numc, edraw, job) {
-    const segData = bzList.map(
-      (bz) => bz !== void 0 && bz.size >= 4 ? buildOffsetLists(bz.list, (2 + numc) / 2) : { offlist: [], tmplist: [] }
-    );
-    const colors = parseSegs(colorAttr).segs.map((s) => s.color ?? "black");
-    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));
-      }
-    }
-  }
-  /** 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 */
-  emitArrows(buf, ops, job, state3, penOverride) {
-    if (ops === void 0) return;
-    const pen = penOverride !== void 0 ? 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[state3]) >= 5e-4) {
-        this.penwidth[state3] = pw;
-        buf.push(xdotStrOp("S ", "setlinewidth(" + trimFixed3(pw) + ")"));
-      }
-      buf.push(xdotStrOp("S ", "solid"));
-      buf.push(xdotPenColor(pen));
-      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;
-      }
-    }
-  }
   endEdge(e, job) {
     if (!this.edgeDrawable) {
-      this.resetState(9 /* EDraw */, 11 /* ELabel */);
-      this.resetState(3 /* HDraw */, 2 /* TDraw */);
-      this.penwidth[7 /* HLabel */] = 1;
-      this.penwidth[6 /* TLabel */] = 1;
+      this.resetEdgeState();
       return;
     }
     renderEdgeLabels(e, this, job);
-    const draw = this.flush(9 /* EDraw */);
-    const hdraw = this.flush(3 /* HDraw */);
-    const tdraw = this.flush(2 /* TDraw */);
-    const ldraw = this.flush(11 /* ELabel */);
-    const hldraw = this.flush(7 /* HLabel */);
-    const tldraw = this.flush(6 /* TLabel */);
-    if (draw || hdraw || tdraw || ldraw || hldraw || tldraw) {
-      const set = this.drawsFor(e);
-      if (draw) set.draw = draw;
-      if (hdraw) set.hdraw = hdraw;
-      if (tdraw) set.tdraw = tdraw;
-      if (ldraw) set.ldraw = escBackslash(ldraw);
-      if (hldraw) set.hldraw = escBackslash(hldraw);
-      if (tldraw) set.tldraw = escBackslash(tldraw);
+    this.attachEdgeDraws(e);
+    this.resetEdgeState();
+    this.textflags[7 /* HLabel */] = 0;
+    this.textflags[6 /* TLabel */] = 0;
+  }
+  /** 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 */
+  attachEdgeDraws(e) {
+    const spec = [
+      [9 /* EDraw */, "draw", false],
+      [3 /* HDraw */, "hdraw", false],
+      [2 /* TDraw */, "tdraw", false],
+      [11 /* ELabel */, "ldraw", true],
+      [7 /* HLabel */, "hldraw", true],
+      [6 /* TLabel */, "tldraw", true]
+    ];
+    const flushed = spec.map(([state3, field, isLabel]) => [field, this.flush(state3), isLabel]);
+    if (!flushed.some(([, s]) => s)) return;
+    const set = this.drawsFor(e);
+    for (const [field, s, isLabel] of flushed) {
+      if (s) set[field] = isLabel ? escBackslash(s) : s;
     }
+  }
+  /** 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. */
+  resetEdgeState() {
     this.resetState(9 /* EDraw */, 11 /* ELabel */);
     this.resetState(3 /* HDraw */, 2 /* TDraw */);
     this.penwidth[7 /* HLabel */] = 1;
     this.penwidth[6 /* TLabel */] = 1;
-    this.textflags[7 /* HLabel */] = 0;
-    this.textflags[6 /* TLabel */] = 0;
   }
   beginCluster(_sg, _job) {
   }
@@ -46872,273 +48063,19 @@ var XdotRenderer = class {
     return d;
   }
   // --- serialization (agwrite-at-end) ------------------------------------
-  /**
-   * 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)
-   */
-  drawAttr(key, value) {
-    return key + '="' + agcanonEscape(value) + '"';
-  }
-  /** `llx,lly,urx,ury` from a graph's layout bb. */
-  bbStr(g) {
-    const bb = g.info.bb;
-    return gfmt5(bb.ll.x) + "," + gfmt5(bb.ll.y) + "," + gfmt5(bb.ur.x) + "," + gfmt5(bb.ur.y);
-  }
-  /**
-   * 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
-   */
-  serialize(g) {
-    const ctx = {
-      out: [],
-      preorder: /* @__PURE__ */ new Map(),
-      nodeLW: /* @__PURE__ */ new Map(),
-      edgeLW: /* @__PURE__ */ new Map(),
-      attrsWritten: /* @__PURE__ */ new Set(),
-      level: 0
-    };
-    this.subgdfs(g, 1, ctx.preorder);
-    this.writeHdr(g, true, ctx);
-    this.writeBody(g, ctx);
-    this.writeTrl(ctx);
-    return ctx.out.join("");
-  }
-  /** Preorder-number the subgraph tree. @see write.c:subgdfs */
-  subgdfs(g, ix, preorder) {
-    let ix0 = ix;
-    preorder.set(g, ix0);
-    for (const sub of g.subgraphs.values()) ix0 = this.subgdfs(sub, ix0, preorder);
-    return ix0 + 1;
-  }
-  /** A subgraph is anonymous when its name is empty or a `%N` local name. */
-  isAnonymous(g) {
-    return g.name.length === 0 || g.name.charCodeAt(0) === 37;
-  }
-  /** 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 */
-  hasBb(g) {
-    return g === g.root || this.clusters.includes(g);
-  }
-  /** 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 */
-  irrelevantSubgraph(g) {
-    if (!this.isAnonymous(g)) return false;
-    if (this.clusters.includes(g)) return false;
-    if (g.nodeDefaults.size > 0 || g.edgeDefaults.size > 0) return false;
-    if (g.parent) {
-      if (this.hasBb(g) !== this.hasBb(g.parent)) return false;
-      for (const [k, v] of g.attrs) {
-        if (g.parent.attrs.get(k) !== v) return false;
-      }
-    } else if (g.attrs.size > 0) {
-      return false;
-    }
-    return true;
-  }
-  /** 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 */
-  subgGraphAttrs(sg) {
-    if (this.clusters.includes(sg)) return this.clusterAttrs(sg);
-    const parts = [];
-    const rank3 = sg.attrs.get("rank");
-    if (rank3 !== void 0) parts.push("rank=" + xdotId(rank3));
-    parts.push(...echoAttr(sg.attrs, "bb"));
-    parts.push(...graphLabelAttrs(sg));
-    return parts.join(" ");
-  }
-  indent(ctx) {
-    return "	".repeat(ctx.level);
-  }
-  /** @see write.c:write_hdr */
-  writeHdr(g, top, ctx) {
-    if (top) {
-      const strict = g.kind === "strict-directed" || g.kind === "strict-undirected" ? "strict " : "";
-      const kw = isDirected(g) ? "digraph" : "graph";
-      const nm = g.name.length > 0 && !this.isAnonymous(g) ? xdotId(g.name) + " " : "";
-      ctx.out.push(strict + kw + " " + nm + "{\n");
-      ctx.level++;
-      ctx.out.push(this.indent(ctx) + "graph [" + this.graphAttrs(g) + "];\n");
-      ctx.out.push(this.indent(ctx) + 'node [label="\\N"];\n');
-    } else {
-      const nm = this.isAnonymous(g) ? "" : "subgraph " + xdotId(g.name) + " ";
-      ctx.out.push(this.indent(ctx) + nm + "{\n");
-      ctx.level++;
-      const ga = this.subgGraphAttrs(g);
-      if (ga) ctx.out.push(this.indent(ctx) + "graph [" + ga + "];\n");
-    }
-  }
-  /** @see write.c:write_trl */
-  writeTrl(ctx) {
-    ctx.level--;
-    ctx.out.push(this.indent(ctx) + "}\n");
-  }
-  /** @see write.c:write_subgs */
-  writeSubgs(g, ctx) {
-    for (const sub of g.subgraphs.values()) {
-      if (this.irrelevantSubgraph(sub)) {
-        this.writeSubgs(sub, ctx);
-      } else {
-        this.writeHdr(sub, false, ctx);
-        this.writeBody(sub, ctx);
-        this.writeTrl(ctx);
-      }
-    }
-  }
-  /** @see write.c:write_body — subgraphs, then this scope's nodes and edges. */
-  writeBody(g, ctx) {
-    this.writeSubgs(g, ctx);
-    for (const n of g.nodes.values()) {
-      if (this.writeNodeTest(g, n, ctx)) this.writeNode(g, n, ctx);
-      let prev = n;
-      for (const e of n.outEdges(g)) {
-        if (prev !== e.head && this.writeNodeTest(g, e.head, ctx)) {
-          this.writeNode(g, e.head, ctx);
-          prev = e.head;
-        }
-        if (this.writeEdgeTest(g, e, ctx)) this.writeEdge(g, e, ctx);
-      }
-    }
-  }
-  /** @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 */
-  writeNodeTest(g, n, ctx) {
-    if (n.info.clustnode) return false;
-    return (ctx.nodeLW.get(n) ?? 0) < ctx.preorder.get(g);
-  }
-  /** 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 */
-  emitNodeName(n) {
-    if (n.info.clustnode) {
-      const i = n.name.indexOf(":");
-      if (i >= 0) return n.name.slice(i + 1);
-    }
-    return n.name;
-  }
-  /** @see write.c:write_edge_test */
-  writeEdgeTest(g, e, ctx) {
-    return (ctx.edgeLW.get(e) ?? 0) < ctx.preorder.get(g);
-  }
-  /** @see write.c:write_node */
-  writeNode(g, n, ctx) {
-    let s = this.indent(ctx) + xdotId(this.emitNodeName(n));
-    if (!ctx.attrsWritten.has(n)) {
-      s += " [" + this.nodeAttrs(n) + "]";
-      ctx.attrsWritten.add(n);
-    }
-    ctx.out.push(s + ";\n");
-    ctx.nodeLW.set(n, ctx.preorder.get(g));
-  }
-  /** @see write.c:write_edge — attrs only on first emission, bare thereafter. */
-  writeEdge(g, e, ctx) {
-    const conn = edgeConnector(isDirected(g));
-    let s = this.indent(ctx) + xdotId(this.emitNodeName(e.tail)) + " " + conn + " " + xdotId(this.emitNodeName(e.head));
-    if (!ctx.attrsWritten.has(e)) {
-      const attrs = this.edgeAttrStr(e);
-      if (attrs) s += " [" + attrs + "]";
-      ctx.attrsWritten.add(e);
-    }
-    ctx.out.push(s + ";\n");
-    ctx.edgeLW.set(e, ctx.preorder.get(g));
+};
+var DotRenderer = class extends XdotRenderer {
+  type = "dot";
+  emitDraws = false;
+  textspan(_pos, _span, _job) {
   }
-  /** Root-graph attribute block: `_draw_`, `_ldraw_`, `bb`, `xdotversion`. */
-  graphAttrs(g) {
-    const d = this.draws.get(g);
-    const parts = [];
-    if (d?.draw) parts.push(this.drawAttr("_draw_", d.draw));
-    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
-    parts.push('bb="' + this.bbStr(g) + '"');
-    parts.push(...graphLabelAttrs(g));
-    parts.push('xdotversion="' + XDOT_VERSION + '"');
-    return parts.join(" ");
+  ellipse(_c, _rx, _ry, _f, _j) {
   }
-  /** 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 */
-  clusterAttrs(sg) {
-    const d = this.draws.get(sg);
-    const parts = [this.drawAttr("_draw_", d?.draw ?? "")];
-    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
-    if (sg.info.bb) parts.push('bb="' + this.bbStr(sg) + '"');
-    parts.push(...graphLabelAttrs(sg));
-    return parts.join(" ");
+  polygon(_pts, _filled, _job) {
   }
-  /** Node attribute block: pos/width/height plus `_draw_`/`_ldraw_`. */
-  nodeAttrs(n) {
-    const info = n.info;
-    let s = 'pos="' + gfmt5(info.coord.x) + "," + gfmt5(info.coord.y) + '" width=' + gfmt5((info.lw + info.rw) / 72) + " height=" + gfmt5(info.ht / 72);
-    const xlabel = info.xlabel;
-    if (xlabel && xlabel.set) s += ' xlp="' + lpStr(xlabel.pos) + '"';
-    else s += pfx(echoAttr(n.attrs, "xlp"));
-    const shape = info.shape;
-    if (shape?.name === "record") {
-      const rects = [];
-      appendRecordRects(n, info.shape_info, rects);
-      s += ' rects="' + rects.join(" ") + '"';
-    } else {
-      s += pfx(echoAttr(n.attrs, "rects"));
-    }
-    const d = this.draws.get(n);
-    if (d?.draw) s += " " + this.drawAttr("_draw_", d.draw);
-    if (d?.ldraw) s += " " + this.drawAttr("_ldraw_", d.ldraw);
-    return s;
+  bezier(_pts, _filled, _job) {
   }
-  /** The `[...]` attribute body for an edge (draw ops + spline `pos`), or ''. */
-  edgeAttrStr(e) {
-    const d = this.draws.get(e);
-    const parts = [];
-    if (d?.draw) parts.push(this.drawAttr("_draw_", d.draw));
-    if (d?.ldraw) parts.push(this.drawAttr("_ldraw_", d.ldraw));
-    if (d?.hdraw) parts.push(this.drawAttr("_hdraw_", d.hdraw));
-    if (d?.tdraw) parts.push(this.drawAttr("_tdraw_", d.tdraw));
-    if (d?.hldraw) parts.push(this.drawAttr("_hldraw_", d.hldraw));
-    if (d?.tldraw) parts.push(this.drawAttr("_tldraw_", d.tldraw));
-    const pos = formatEdgePos(e);
-    if (pos) {
-      parts.push(pos);
-    } else {
-      parts.push(...echoAttr(e.attrs, "pos"));
-    }
-    const attached = edgeAttrsAttached(e);
-    const info = e.info;
-    if (attached && info.label) parts.push('lp="' + lpStr(info.label.pos) + '"');
-    else parts.push(...echoAttr(e.attrs, "lp"));
-    if (attached && info.xlabel && info.xlabel.set) {
-      parts.push('xlp="' + lpStr(info.xlabel.pos) + '"');
-    } else parts.push(...echoAttr(e.attrs, "xlp"));
-    if (attached && info.head_label) {
-      parts.push('head_lp="' + lpStr(info.head_label.pos) + '"');
-    } else parts.push(...echoAttr(e.attrs, "head_lp"));
-    if (attached && info.tail_label) {
-      parts.push('tail_lp="' + lpStr(info.tail_label.pos) + '"');
-    } else parts.push(...echoAttr(e.attrs, "tail_lp"));
-    return parts.join(" ");
+  polyline(_pts, _job) {
   }
 };
 function createDotRenderer() {
@@ -50893,7 +51830,7 @@ function portStringOf(item) {
   if (ni.port === null || ni.port === "") return "";
   return ni.compass ? ni.port + ":" + ni.compass : ni.port;
 }
-function effectiveNodeDefaults(scope) {
+function effectiveNodeDefaults2(scope) {
   const eff = /* @__PURE__ */ new Map();
   for (let g = scope; g !== null; g = g.parent) {
     for (const [k, v] of g.nodeDefaults) {
@@ -50921,7 +51858,7 @@ var NodeRegistry = class {
     const existing = root.nodes.get(name);
     if (existing !== void 0) return existing;
     const node = new Node(this.nextId++, name, root);
-    node.nodeDefaultsSnapshot = effectiveNodeDefaults(scope);
+    node.nodeDefaultsSnapshot = effectiveNodeDefaults2(scope);
     root.nodes.set(name, node);
     return node;
   }
@@ -50949,7 +51886,7 @@ var NameCollector = class _NameCollector {
     }
   }
 };
-var StmtProcessor = class {
+var StmtProcessor = class _StmtProcessor {
   constructor(registry) {
     this.registry = registry;
   }
@@ -50968,6 +51905,41 @@ var StmtProcessor = class {
    * @see lib/cgraph/id.c:agnameof (`'%' + id`)
    */
   anonCounter = 0;
+  /**
+   * Strict-graph edge index: canonical endpoint-pair key → the edge already
+   * created for it. `agedge` on a strict graph probes for a pre-existing edge
+   * and returns it instead of creating a second one, so `strict digraph
+   * { a->b; a->b }` holds ONE edge. A Map (rather than scanning root.edges)
+   * keeps that probe O(1); it stays empty for non-strict graphs.
+   * @see lib/cgraph/edge.c:agedge (agfindedge_by_key probe, :262-287)
+   */
+  strictEdges = /* @__PURE__ */ new Map();
+  /**
+   * Canonical key for a strict-graph endpoint pair. C probes (t,h) and then,
+   * for an UNDIRECTED graph, (h,t) — so an undirected pair matches either way
+   * round and is canonicalized here by node id; a directed pair is not.
+   * @see lib/cgraph/edge.c:agedge:274-275 (`if (e == NULL && agisundirected(g))`)
+   */
+  static strictKey(tail, head, undirected) {
+    const swap2 = undirected && head.id < tail.id;
+    return swap2 ? `${head.id}\0${tail.id}` : `${tail.id}\0${head.id}`;
+  }
+  /**
+   * Apply the DOT-syntax `:port:compass` endpoints to an edge's attrs.
+   *
+   * C's precedence is explicit attr > `:port` syntax > edge default (verified
+   * against the oracle: with `edge [headport=n]` declared, `a:e -> b:sw` yields
+   * headport `sw`, while `c:e -> d:sw [headport=w]` yields `w`). The guard is
+   * therefore against THIS statement's own attribute list — not the edge's
+   * accumulated map, which also holds inherited defaults and, for a strict
+   * duplicate, the earlier statement's values.
+   * @see lib/cgraph/grammar.y:396 (mkport)
+   */
+  static applySyntaxPorts(target, stmtAttrs, tailPort, headPort) {
+    const setByStmt = (k) => stmtAttrs.some((a) => a.key === k);
+    if (tailPort && !setByStmt("tailport")) target.set("tailport", tailPort);
+    if (headPort && !setByStmt("headport")) target.set("headport", headPort);
+  }
   /** Consume one anonymous id, returning cgraph's `2*counter+1`. */
   nextAnonId() {
     return this.anonCounter++ * 2 + 1;
@@ -50983,12 +51955,21 @@ var StmtProcessor = class {
   }
   processAssign(stmt, graph) {
     graph.attrs.set(stmt.key, normaliseAttrValue(stmt.value));
-    graph.root.declaredGraphAttrs.add(stmt.key);
+    this.declareGraphAttr(graph, stmt.key);
+  }
+  /** Record a graph-attribute declaration, noting whether THIS scope was the
+   *  first to declare the key anywhere — the branch selector in cgraph's
+   *  setattr. @see lib/cgraph/attr.c:257 · model/graph.ts firstGraphDecl */
+  declareGraphAttr(graph, key) {
+    if (!graph.root.declaredGraphAttrs.has(key)) {
+      (graph.firstGraphDecl ??= /* @__PURE__ */ new Set()).add(key);
+      graph.root.declaredGraphAttrs.add(key);
+    }
   }
   processAttr(stmt, graph) {
     if (stmt.target === "graph") {
       applyAttrs(stmt.attrs, graph.attrs);
-      for (const a of stmt.attrs) graph.root.declaredGraphAttrs.add(a.key);
+      for (const a of stmt.attrs) this.declareGraphAttr(graph, a.key);
     } else if (stmt.target === "node") {
       applyAttrs(stmt.attrs, graph.nodeDefaults);
     } else {
@@ -51023,7 +52004,10 @@ var StmtProcessor = class {
     buildGraph(stmt.stmts, sg, root, directed, this);
     for (const key of GRAPH_LABEL_INHERIT_KEYS) {
       const v = sg.graphDefaultsSnapshot.get(key);
-      if (v !== void 0 && !sg.attrs.has(key)) sg.attrs.set(key, v);
+      if (v !== void 0 && !sg.attrs.has(key)) {
+        sg.attrs.set(key, v);
+        (sg.seededAttrs ??= /* @__PURE__ */ new Set()).add(key);
+      }
     }
     graph.subgraphs.set(sgName, sg);
     return sg;
@@ -51073,14 +52057,28 @@ var StmtProcessor = class {
   connectEndpoints(tailEnd, headEnd, attrs, graph, root) {
     const tailPort = tailEnd.port;
     const headPort = headEnd.port;
+    const strict = root.kind === "strict-directed" || root.kind === "strict-undirected";
+    const undirected = root.kind === "strict-undirected";
     for (const tail of tailEnd.nodes) {
       for (const head of headEnd.nodes) {
+        const key = strict ? _StmtProcessor.strictKey(tail, head, undirected) : "";
+        const existing = strict ? this.strictEdges.get(key) : void 0;
+        if (existing !== void 0) {
+          applyAttrs(attrs, existing.attrs);
+          _StmtProcessor.applySyntaxPorts(existing.attrs, attrs, tailPort, headPort);
+          for (let g = graph; g !== null && g !== root; g = g.parent) {
+            g.nodes.set(tail.name, tail);
+            g.nodes.set(head.name, head);
+            if (!g.edges.includes(existing)) g.edges.push(existing);
+          }
+          continue;
+        }
         const edge = new Edge(tail, head, "");
         this.advanceAnonId();
         applyAttrs(attrs, edge.attrs);
+        _StmtProcessor.applySyntaxPorts(edge.attrs, attrs, tailPort, headPort);
         this.snapshotEdgeDefaults(edge, graph);
-        if (tailPort && !edge.attrs.has("tailport")) edge.attrs.set("tailport", tailPort);
-        if (headPort && !edge.attrs.has("headport")) edge.attrs.set("headport", headPort);
+        if (strict) this.strictEdges.set(key, edge);
         root.edges.push(edge);
         edge.graphSeq = root.edges.length;
         for (let g = graph; g !== null && g !== root; g = g.parent) {
@@ -51823,596 +52821,217 @@ function graphEffectiveAttrs(g, top) {
   for (const [k, v] of g.attrs) m.set(k, v);
   return m;
 }
-function isEdgeLabelDeclared(g) {
-  for (const e of g.edges) if (e.attrs.has("label")) return true;
-  const walk = (sg) => {
-    if (sg.edgeDefaults.has("label")) return true;
-    for (const [, sub] of sg.subgraphs) if (walk(sub)) return true;
-    return false;
-  };
-  return walk(g);
-}
-function dfsSubgraphs(g, out) {
-  for (const [, sg] of g.subgraphs) {
-    out.push(sg);
-    dfsSubgraphs(sg, out);
-  }
-}
-function assignIds(g, doXDot, draws) {
-  const dfsSubs = [];
-  dfsSubgraphs(g, dfsSubs);
-  const subgGid = /* @__PURE__ */ new Map();
-  dfsSubs.forEach((sg, i) => subgGid.set(sg, i));
-  const sgcnt = dfsSubs.length;
-  const nodeGid = /* @__PURE__ */ new Map();
-  let ncnt = 0;
-  for (const [, n] of g.nodes) nodeGid.set(n, sgcnt + ncnt++);
-  const edgeGid = /* @__PURE__ */ new Map();
-  let ecnt = 0;
-  for (const { e } of canonicalRootEdges(g)) edgeGid.set(e, ecnt++);
-  return {
-    doXDot,
-    draws,
-    sgcnt,
-    subgGid,
-    nodeGid,
-    edgeGid,
-    dfsSubs,
-    edgeLabelDeclared: isEdgeLabelDeclared(g),
-    graphLabelDeclared: isGraphLabelDeclared(g),
-    isLatin: g.info.charset === CHAR_LATIN1
-  };
-}
-function emitAttrs(o, base, overlay, ctx) {
-  const merged = new Map(base);
-  if (overlay !== void 0) for (const [k, v] of overlay) merged.set(k, v);
-  for (const [k, rawV] of merged) {
-    const v = isHtmlValue(rawV) ? htmlValueContent(rawV) : rawV;
-    if (v === "" && k !== "label") continue;
-    if (ctx.doXDot && isXDot(k)) {
-      o[k] = drawStringToOps(v, ctx.isLatin);
-    } else if (!isXDot(k)) {
-      o[k] = v;
-    }
-  }
-}
-function graphLabel(info) {
-  const l = info.label;
-  if (l !== void 0 && l !== null && typeof l === "object" && "pos" in l) {
-    return l;
-  }
-  return void 0;
-}
-function labelPos(l) {
-  return gfmt5(l.pos.x) + "," + gfmt5(l.pos.y);
-}
-function attachEdgeLabelPositions(o, e) {
-  if (!e.info.spl) return;
-  if (e.info.label !== void 0) o.lp = labelPos(e.info.label);
-  if (e.info.head_label !== void 0) o.head_lp = labelPos(e.info.head_label);
-  if (e.info.tail_label !== void 0) o.tail_lp = labelPos(e.info.tail_label);
-  const xl = e.info.xlabel;
-  if (xl !== void 0 && xl.set) o.xlp = labelPos(xl);
-}
-function attachNodeXlp(o, n) {
-  const xl = n.info.xlabel;
-  if (xl !== void 0 && xl.set) o.xlp = labelPos(xl);
-}
-function attachGraphLabelGeom(o, g) {
-  const lbl = graphLabel(g.info);
-  if (lbl !== void 0 && lbl.text !== "") {
-    o.lp = gfmt5(lbl.pos.x) + "," + gfmt5(lbl.pos.y);
-    o.lwidth = (lbl.dimen.x / 72).toFixed(2);
-    o.lheight = (lbl.dimen.y / 72).toFixed(2);
-  }
-}
-function setRecordRects(f, coord, out) {
-  if (f.n_flds === 0) {
-    out.push(
-      gfmt5(f.b.ll.x + coord.x) + "," + gfmt5(f.b.ll.y + coord.y) + "," + gfmt5(f.b.ur.x + coord.x) + "," + gfmt5(f.b.ur.y + coord.y)
-    );
-  } else if (f.fld !== null) {
-    for (const sub of f.fld) setRecordRects(sub, coord, out);
-  }
-}
-function attachNodeRects(o, n) {
-  const shape = n.info.shape;
-  if (shape?.name !== "record") return;
-  const f = n.info.shape_info;
-  if (f === void 0) return;
-  const parts = [];
-  setRecordRects(f, n.info.coord, parts);
-  if (parts.length > 0) o.rects = parts.join(" ");
-}
-function nodeEffectiveAttrs(n) {
-  const m = new Map(n.nodeDefaultsSnapshot ?? []);
-  for (const [k, v] of n.attrs) m.set(k, v);
-  if (!m.has("label")) m.set("label", DEFAULT_NODE_LABEL);
-  return m;
-}
-function buildNodeObject(n, ctx) {
-  const o = { _gvid: ctx.nodeGid.get(n), name: n.name };
-  const eff = nodeEffectiveAttrs(n);
-  const xd = ctx.draws?.node.get(n.name);
-  if (xd === void 0) {
-    eff.set("pos", printNum(n.info.coord.x) + "," + printNum(n.info.coord.y));
-    eff.set("width", printNum(n.info.width));
-    eff.set("height", printNum(n.info.height));
-  }
-  emitAttrs(o, eff, xd, ctx);
-  attachNodeRects(o, n);
-  attachNodeXlp(o, n);
-  if (ctx.doXDot && ctx.draws === void 0 && !("_draw_" in o)) o._draw_ = [];
-  return o;
-}
-function buildEdgeObject(e, ctx) {
-  const o = {
-    _gvid: ctx.edgeGid.get(e),
-    tail: ctx.nodeGid.get(e.tail),
-    head: ctx.nodeGid.get(e.head)
-  };
-  emitAttrs(o, e.attrs, ctx.draws?.edge.get(e), ctx);
-  if (ctx.edgeLabelDeclared && !("label" in o)) o.label = "";
-  attachEdgeLabelPositions(o, e);
-  if (ctx.doXDot && ctx.draws === void 0 && !("_draw_" in o)) o._draw_ = [];
-  return o;
-}
-function memberEdgeGids(g, ctx) {
-  const edges = [];
-  for (const [, n] of g.nodes) {
-    for (const e of n.outEdges(g)) {
-      if (ctx.edgeGid.has(e)) edges.push(e);
-    }
-  }
-  edges.sort((a, b) => a.seq - b.seq);
-  return edges.map((e) => ctx.edgeGid.get(e));
-}
-function buildEdgesArray(g, ctx) {
-  const edges = canonicalRootEdges(g).map(({ e }) => e);
-  edges.sort((a, b) => a.seq - b.seq);
-  return edges.map((e) => buildEdgeObject(e, ctx));
-}
-function buildGraphObject(g, top, ctx) {
-  const o = {};
-  o.name = g.name;
-  if (top) {
-    o.directed = g.kind === "directed" || g.kind === "strict-directed";
-    o.strict = g.kind === "strict-directed" || g.kind === "strict-undirected";
-  }
-  const overlay = top ? ctx.draws?.graph : ctx.draws?.cluster.get(g);
-  emitAttrs(o, graphEffectiveAttrs(g, top), overlay, ctx);
-  attachGraphLabelGeom(o, g);
-  if (ctx.graphLabelDeclared && !("label" in o)) o.label = "";
-  if (top) {
-    o._subgraph_cnt = ctx.sgcnt;
-  } else {
-    o._gvid = ctx.subgGid.get(g);
-  }
-  if (top) {
-    if (ctx.dfsSubs.length > 0 || g.nodes.size > 0) {
-      const objects = [];
-      for (const sg of ctx.dfsSubs) objects.push(buildGraphObject(sg, false, ctx));
-      for (const [, n] of g.nodes) objects.push(buildNodeObject(n, ctx));
-      o.objects = objects;
-    }
-  } else {
-    const childGids = [];
-    for (const [, sg] of g.subgraphs) childGids.push(ctx.subgGid.get(sg));
-    if (childGids.length > 0) o.subgraphs = childGids;
-    const nodeGids = [];
-    for (const [, n] of g.nodes) {
-      const gid = ctx.nodeGid.get(n);
-      if (gid !== void 0) nodeGids.push(gid);
-    }
-    if (nodeGids.length > 0) o.nodes = nodeGids;
-    const eGids = memberEdgeGids(g, ctx);
-    if (eGids.length > 0) o.edges = eGids;
-  }
-  if (top) {
-    const edges = buildEdgesArray(g, ctx);
-    if (edges.length > 0) o.edges = edges;
-  }
-  return o;
-}
-function latin1Reencode(s) {
-  const bytes = new TextEncoder().encode(s);
-  let out = "";
-  for (const b of bytes) out += String.fromCharCode(b);
-  return out;
-}
-function buildJson(g, doXDot) {
-  const draws = doXDot ? collectDrawLookup(g) : void 0;
-  const ctx = assignIds(g, doXDot, draws);
-  const root = buildGraphObject(g, true, ctx);
-  return JSON.stringify(root, null, 2) + "\n";
-}
-var Json0Renderer = class {
-  type = "json0";
-  /** @see plugin/core/gvplugin_core.c registration table */
-  quality = 0;
-  beginGraph(_g, _job) {
-  }
-  endGraph(g, job) {
-    job.write(buildJson(g, false));
-  }
-  beginNode(_n, _job) {
-  }
-  endNode(_n, _job) {
-  }
-  beginEdge(_e, _job) {
-  }
-  endEdge(_e, _job) {
-  }
-  textspan(_pos, _span, _job) {
-  }
-  ellipse(_c, _rx, _ry, _f, _j) {
-  }
-  polygon(_pts, _filled, _job) {
-  }
-  bezier(_pts, _filled, _job) {
-  }
-  polyline(_pts, _job) {
-  }
-};
-var JsonRenderer = class {
-  type = "json";
-  /** @see plugin/core/gvplugin_core.c registration table */
-  quality = 0;
-  beginGraph(_g, _job) {
-  }
-  endGraph(g, job) {
-    job.write(buildJson(g, true));
-  }
-  beginNode(_n, _job) {
-  }
-  endNode(_n, _job) {
-  }
-  beginEdge(_e, _job) {
-  }
-  endEdge(_e, _job) {
-  }
-  textspan(_pos, _span, _job) {
-  }
-  ellipse(_c, _rx, _ry, _f, _j) {
-  }
-  polygon(_pts, _filled, _job) {
-  }
-  bezier(_pts, _filled, _job) {
-  }
-  polyline(_pts, _job) {
-  }
-};
-function createJson0Renderer() {
-  return new Json0Renderer();
-}
-function createJsonRenderer() {
-  return new JsonRenderer();
-}
-
-// src/render/map.ts
-var DQ = '"';
-function exactDecimalDigits2(v) {
-  const dv = new DataView(new ArrayBuffer(8));
-  dv.setFloat64(0, Math.abs(v));
-  const bits = dv.getBigUint64(0);
-  const expBits = Number(bits >> 52n & 0x7ffn);
-  const mant = bits & 0xfffffffffffffn;
-  const m = expBits === 0 ? mant : mant | 1n << 52n;
-  const e = (expBits === 0 ? 1 : expBits) - 1075;
-  let intDigits;
-  let fracLen = 0;
-  if (e >= 0) {
-    intDigits = (m << BigInt(e)).toString();
-  } else {
-    intDigits = (m * 5n ** BigInt(-e)).toString();
-    fracLen = -e;
-  }
-  if (intDigits.length <= fracLen) {
-    intDigits = "0".repeat(fracLen - intDigits.length + 1) + intDigits;
-  }
-  const pointPos = intDigits.length - fracLen;
-  const firstSig = intDigits.search(/[1-9]/);
-  return { digits: intDigits.slice(firstSig), exp10: pointPos - firstSig - 1 };
-}
-function printG5(v) {
-  if (v === 0 || !Number.isFinite(v)) return String(v);
-  const P = 5;
-  const { digits, exp10 } = exactDecimalDigits2(v);
-  let sig = digits.slice(0, P);
-  if (sig.length < P) sig += "0".repeat(P - sig.length);
-  const rest = digits.slice(P);
-  const restNonzeroAfterFirst = /[1-9]/.test(rest.slice(1));
-  const roundUp = rest.length > 0 && (rest[0] > "5" || rest[0] === "5" && restNonzeroAfterFirst || rest[0] === "5" && !restNonzeroAfterFirst && (sig.charCodeAt(P - 1) - 48) % 2 === 1);
-  let exp = exp10;
-  if (roundUp) {
-    const n = String(BigInt(sig) + 1n);
-    sig = n.length > P ? (exp++, n.slice(0, P)) : n;
-  }
-  const sign2 = v < 0 ? "-" : "";
-  if (exp < -4 || exp >= P) {
-    const mant = (sig[0] + "." + sig.slice(1)).replace(/\.?0+$/, "");
-    const as = Math.abs(exp);
-    return sign2 + mant + "e" + (exp < 0 ? "-" : "+") + (as < 10 ? "0" : "") + String(as);
-  }
-  let s;
-  if (exp >= sig.length - 1) {
-    s = sig + "0".repeat(exp - sig.length + 1);
-  } else if (exp >= 0) {
-    s = sig.slice(0, exp + 1) + "." + sig.slice(exp + 1);
-  } else {
-    s = "0." + "0".repeat(-exp - 1) + sig;
-  }
-  if (s.includes(".")) s = s.replace(/\.?0+$/, "");
-  return sign2 + s;
-}
-function plainCoord(v) {
-  return printG5(v / 72);
-}
-var CANON_KEYWORDS = ["node", "edge", "strict", "graph", "digraph", "subgraph"];
-var MAX_OUTPUTLINE = 128;
-function isDigitByte(b) {
-  return b >= 48 && b <= 57;
-}
-function isAlnumByte(b) {
-  return isDigitByte(b) || b >= 65 && b <= 90 || b >= 97 && b <= 122;
-}
-function isIdCharByte(b) {
-  return isAlnumByte(b) || b === 46 || b === 45 || b >= 128;
-}
-function isEscapeAt(bytes, i) {
-  if (bytes[i] !== 92) return false;
-  const c = bytes[i + 1];
-  return c !== void 0 && 'EGHLNTlnr\\"'.includes(String.fromCharCode(c));
-}
-function agstrcanonText(arg) {
-  if (arg.length === 0) return '""';
-  const bytes = new TextEncoder().encode(arg);
-  const out = [34];
-  let needsQuotes = false;
-  let partOfEscape = false;
-  let backslashPending = false;
-  let cnt = 0;
-  let dotcnt = 0;
-  let maybeNum = isDigitByte(bytes[0]) || bytes[0] === 46 || bytes[0] === 45;
-  for (let i = 0; i < bytes.length; i++) {
-    const uc = bytes[i];
-    if (uc === 34 && !partOfEscape) {
-      out.push(92);
-      needsQuotes = true;
-    } else if (!partOfEscape && isEscapeAt(bytes, i)) {
-      needsQuotes = true;
-      partOfEscape = true;
-    } else if (maybeNum) {
-      if (uc === 45) {
-        if (cnt) {
-          maybeNum = false;
-          needsQuotes = true;
-        }
-      } else if (uc === 46) {
-        if (dotcnt++) {
-          maybeNum = false;
-          needsQuotes = true;
-        }
-      } else if (!isDigitByte(uc)) {
-        maybeNum = false;
-        needsQuotes = true;
-      }
-      partOfEscape = false;
-    } else if (!(isAlnumByte(uc) || uc === 95 || uc >= 128)) {
-      needsQuotes = true;
-      partOfEscape = false;
-    } else {
-      partOfEscape = false;
-    }
-    out.push(uc);
-    cnt++;
-    const next = bytes[i + 1];
-    if (next !== void 0) {
-      const last = out[out.length - 1];
-      const canBreak = !(isIdCharByte(last) || last === 92) && isIdCharByte(next);
-      if (backslashPending && canBreak) {
-        out.push(92, 10);
-        needsQuotes = true;
-        backslashPending = false;
-        cnt = 0;
-      } else if (cnt >= MAX_OUTPUTLINE) {
-        if (canBreak) {
-          out.push(92, 10);
-          needsQuotes = true;
-          cnt = 0;
-        } else {
-          backslashPending = true;
-        }
-      }
-    }
-  }
-  out.push(34);
-  const first = bytes[0];
-  if (needsQuotes || cnt === 1 && (first === 46 || first === 45)) {
-    return new TextDecoder().decode(new Uint8Array(out));
-  }
-  const lower = arg.toLowerCase();
-  for (const tok of CANON_KEYWORDS) {
-    if (tok === lower) return new TextDecoder().decode(new Uint8Array(out));
-  }
-  return arg;
-}
-function lateNN(v, def) {
-  return v !== void 0 && v !== "" ? v : def;
-}
-function plainNodeFill(n, g) {
-  const fillcolor = lateNN(nodeAttr(n, g, "fillcolor"), "");
-  if (fillcolor !== "") return fillcolor;
-  return lateNN(nodeAttr(n, g, "color"), "lightgrey");
-}
-function plainNodeLabel(n, g) {
-  const lbl = n.info.label;
-  const attr2 = nodeAttr(n, g, "label");
-  if (lbl !== void 0 && lbl.u.kind === "html") {
-    const a = attr2 ?? "";
-    return "<" + (isHtmlValue(a) ? htmlValueContent(a) : a) + ">";
-  }
-  if (attr2 !== void 0 && isHtmlValue(attr2) && lbl !== void 0 && lbl.u.kind === "txt") {
-    return agstrcanonText(htmlValueContent(attr2));
-  }
-  const shape = n.info.shape;
-  if (shape !== void 0 && shape.kind === 2 /* SH_RECORD */) {
-    return agstrcanonText(nodeAttr(n, g, "label") ?? "\\N");
+function isEdgeLabelDeclared(g) {
+  for (const e of g.edges) if (e.attrs.has("label")) return true;
+  const walk = (sg) => {
+    if (sg.edgeDefaults.has("label")) return true;
+    for (const [, sub] of sg.subgraphs) if (walk(sub)) return true;
+    return false;
+  };
+  return walk(g);
+}
+function dfsSubgraphs(g, out) {
+  for (const [, sg] of g.subgraphs) {
+    out.push(sg);
+    dfsSubgraphs(sg, out);
   }
-  const text = lbl !== void 0 ? lbl.text : n.attrs.get("label") ?? n.name;
-  return agstrcanonText(text);
 }
-function plainNodeAttrs(n, g) {
-  const shapeAttr = lateNN(nodeAttr(n, g, "shape"), "ellipse");
-  const shapefile = nodeAttr(n, g, "shapefile");
-  const shapeName = shapefile !== void 0 && shapefile !== "" && shapeAttr !== "epsf" ? "custom" : shapeAttr;
+function assignIds(g, doXDot, draws) {
+  const dfsSubs = [];
+  dfsSubgraphs(g, dfsSubs);
+  const subgGid = /* @__PURE__ */ new Map();
+  dfsSubs.forEach((sg, i) => subgGid.set(sg, i));
+  const sgcnt = dfsSubs.length;
+  const nodeGid = /* @__PURE__ */ new Map();
+  let ncnt = 0;
+  for (const [, n] of g.nodes) nodeGid.set(n, sgcnt + ncnt++);
+  const edgeGid = /* @__PURE__ */ new Map();
+  let ecnt = 0;
+  for (const { e } of canonicalRootEdges(g)) edgeGid.set(e, ecnt++);
   return {
-    label: plainNodeLabel(n, g),
-    style: lateNN(nodeAttr(n, g, "style"), "solid"),
-    shape: shapeName,
-    color: lateNN(nodeAttr(n, g, "color"), "black"),
-    fill: plainNodeFill(n, g)
+    doXDot,
+    draws,
+    sgcnt,
+    subgGid,
+    nodeGid,
+    edgeGid,
+    dfsSubs,
+    edgeLabelDeclared: isEdgeLabelDeclared(g),
+    graphLabelDeclared: isGraphLabelDeclared(g),
+    isLatin: g.info.charset === CHAR_LATIN1
   };
 }
-function writePlainNode(n, g, out) {
-  const x = plainCoord(n.info.coord.x);
-  const y = plainCoord(n.info.coord.y);
-  const w = printG5(n.info.width);
-  const h = printG5(n.info.height);
-  const a = plainNodeAttrs(n, g);
-  out.push("node " + agstrcanonText(n.name) + " " + x + " " + y + " " + w + " " + h + " " + a.label + " " + a.style + " " + a.shape + " " + a.color + " " + a.fill + "\n");
-}
-function collectSplinePts(e) {
-  if (!e.info.spl) return [];
-  const pts = [];
-  for (const bz of e.info.spl.list) {
-    for (let i = 0; i < bz.size; i++) pts.push(bz.list[i]);
-  }
-  return pts;
-}
-function writeNodeAndPort(n, portname, out) {
-  let name = n.name;
-  if (n.info.clustnode) {
-    const i = name.indexOf(":");
-    if (i >= 0) name = name.slice(i + 1);
+function emitAttrs(o, base, overlay, ctx) {
+  const merged = new Map(base);
+  if (overlay !== void 0) for (const [k, v] of overlay) merged.set(k, v);
+  for (const [k, rawV] of merged) {
+    const v = isHtmlValue(rawV) ? htmlValueContent(rawV) : rawV;
+    if (v === "" && k !== "label") continue;
+    if (ctx.doXDot && isXDot(k)) {
+      o[k] = drawStringToOps(v, ctx.isLatin);
+    } else if (!isXDot(k)) {
+      o[k] = v;
+    }
   }
-  out.push(" " + agstrcanonText(name));
-  if (portname !== "") out.push(":" + agstrcanonText(portname));
 }
-function writePlainEdgeHead(e, tport, hport, pts, out) {
-  out.push("edge");
-  writeNodeAndPort(e.tail, tport, out);
-  writeNodeAndPort(e.head, hport, out);
-  out.push(" " + String(pts.length));
-  for (const pt of pts) {
-    out.push(" " + plainCoord(pt.x) + " " + plainCoord(pt.y));
+function graphLabel(info) {
+  const l = info.label;
+  if (l !== void 0 && l !== null && typeof l === "object" && "pos" in l) {
+    return l;
   }
+  return void 0;
 }
-function writePlainEdge(e, extend, out) {
-  const tport = extend ? e.attrs.get("tailport") ?? "" : "";
-  const hport = extend ? e.attrs.get("headport") ?? "" : "";
-  const pts = collectSplinePts(e);
-  if (pts.length > 0) writePlainEdgeHead(e, tport, hport, pts, out);
-  const lbl = e.info.label;
-  if (lbl !== void 0) {
-    out.push(" " + agstrcanonText(lbl.text) + " " + plainCoord(lbl.pos.x) + " " + plainCoord(lbl.pos.y));
-  }
-  const style = lateNN(e.attrs.get("style"), "solid");
-  const color = lateNN(e.attrs.get("color"), "black");
-  out.push(" " + style + " " + color + "\n");
+function labelPos(l) {
+  return gfmt5(l.pos.x) + "," + gfmt5(l.pos.y);
 }
-function writePlain(g, job, extend) {
-  const w = plainCoord(g.info.bb.ur.x);
-  const h = plainCoord(g.info.bb.ur.y);
-  const zoom = initJobViewportZoom(
-    job.bb,
-    parseDrawingSize(g.attrs.get("size")),
-    { x: 0, y: 0 }
-  );
-  job.write("graph " + printG5(zoom) + " " + w + " " + h + "\n");
-  const nodes = nodesInSeq(g);
-  for (const n of nodes) {
-    if (n.info.clustnode) continue;
-    const buf = [];
-    writePlainNode(n, g, buf);
-    job.write(buf.join(""));
-  }
-  for (const n of nodes) {
-    for (const e of n.outEdges(g)) {
-      const buf = [];
-      writePlainEdge(e, extend, buf);
-      job.write(buf.join(""));
-    }
-  }
-  job.write("stop\n");
+function attachEdgeLabelPositions(o, e) {
+  if (!e.info.spl) return;
+  if (e.info.label !== void 0) o.lp = labelPos(e.info.label);
+  if (e.info.head_label !== void 0) o.head_lp = labelPos(e.info.head_label);
+  if (e.info.tail_label !== void 0) o.tail_lp = labelPos(e.info.tail_label);
+  const xl = e.info.xlabel;
+  if (xl !== void 0 && xl.set) o.xlp = labelPos(xl);
 }
-function cmapxObjAnchor(obj) {
-  return {
-    url: obj.url ?? "",
-    tooltip: obj.tooltip ?? "",
-    target: obj.target ?? "",
-    id: obj.id ?? ""
-  };
+function attachNodeXlp(o, n) {
+  const xl = n.info.xlabel;
+  if (xl !== void 0 && xl.set) o.xlp = labelPos(xl);
 }
-function writeCmapxGraphShape(job, out) {
-  const obj = job.obj;
-  if (!obj || !obj.urlMapPts.length) return;
-  mapOutputCmapx(obj.urlMapShape, obj.urlMapPts, cmapxObjAnchor(obj), true, out);
+function attachGraphLabelGeom(o, g) {
+  const lbl = graphLabel(g.info);
+  if (lbl !== void 0 && lbl.text !== "") {
+    o.lp = gfmt5(lbl.pos.x) + "," + gfmt5(lbl.pos.y);
+    o.lwidth = (lbl.dimen.x / 72).toFixed(2);
+    o.lheight = (lbl.dimen.y / 72).toFixed(2);
+  }
 }
-function cmapxShape(shape) {
-  if (shape === 1 /* Circle */) return "circle";
-  if (shape === 0 /* Rectangle */) return "rect";
-  return "poly";
+function setRecordRects(f, coord, out) {
+  if (f.n_flds === 0) {
+    out.push(
+      gfmt5(f.b.ll.x + coord.x) + "," + gfmt5(f.b.ll.y + coord.y) + "," + gfmt5(f.b.ur.x + coord.x) + "," + gfmt5(f.b.ur.y + coord.y)
+    );
+  } else if (f.fld !== null) {
+    for (const sub of f.fld) setRecordRects(sub, coord, out);
+  }
 }
-function cmapxCoordsRect(pts) {
-  return String(Math.round(pts[0].x)) + "," + String(Math.round(pts[1].y)) + "," + String(Math.round(pts[1].x)) + "," + String(Math.round(pts[0].y));
+function attachNodeRects(o, n) {
+  const shape = n.info.shape;
+  if (shape?.name !== "record") return;
+  const f = n.info.shape_info;
+  if (f === void 0) return;
+  const parts = [];
+  setRecordRects(f, n.info.coord, parts);
+  if (parts.length > 0) o.rects = parts.join(" ");
 }
-function cmapxCoordsCircle(pts) {
-  const cx = Math.round(pts[0].x);
-  const cy = Math.round(pts[0].y);
-  const r = Math.round(pts[1].x - pts[0].x);
-  return String(cx) + "," + String(cy) + "," + String(r);
+function nodeEffectiveAttrs(n) {
+  const m = new Map(n.nodeDefaultsSnapshot ?? []);
+  for (const [k, v] of n.attrs) m.set(k, v);
+  if (!m.has("label")) m.set("label", DEFAULT_NODE_LABEL);
+  return m;
 }
-function cmapxCoordsPoly(pts) {
-  return pts.map((p) => String(Math.round(p.x)) + "," + String(Math.round(p.y))).join(",");
+function buildNodeObject(n, ctx) {
+  const o = { _gvid: ctx.nodeGid.get(n), name: n.name };
+  const eff = nodeEffectiveAttrs(n);
+  const xd = ctx.draws?.node.get(n.name);
+  if (xd === void 0) {
+    eff.set("pos", printNum(n.info.coord.x) + "," + printNum(n.info.coord.y));
+    eff.set("width", printNum(n.info.width));
+    eff.set("height", printNum(n.info.height));
+  }
+  emitAttrs(o, eff, xd, ctx);
+  attachNodeRects(o, n);
+  attachNodeXlp(o, n);
+  if (ctx.doXDot && ctx.draws === void 0 && !("_draw_" in o)) o._draw_ = [];
+  return o;
 }
-function cmapxCoords(shape, pts) {
-  if (shape === 1 /* Circle */) return cmapxCoordsCircle(pts);
-  if (shape === 0 /* Rectangle */) return cmapxCoordsRect(pts);
-  return cmapxCoordsPoly(pts);
+function buildEdgeObject(e, ctx) {
+  const o = {
+    _gvid: ctx.edgeGid.get(e),
+    tail: ctx.nodeGid.get(e.tail),
+    head: ctx.nodeGid.get(e.head)
+  };
+  emitAttrs(o, e.attrs, ctx.draws?.edge.get(e), ctx);
+  if (ctx.edgeLabelDeclared && !("label" in o)) o.label = "";
+  attachEdgeLabelPositions(o, e);
+  if (ctx.doXDot && ctx.draws === void 0 && !("_draw_" in o)) o._draw_ = [];
+  return o;
 }
-function mapCmapxAttrs(a, out) {
-  if (a.id) out.push(" id=" + DQ + escapeXml(a.id) + DQ);
-  if (a.url) out.push(" href=" + DQ + escapeXml(a.url) + DQ);
-  if (a.target) out.push(" target=" + DQ + escapeXmlTitle(a.target) + DQ);
-  if (a.tooltip) out.push(" title=" + DQ + escapeXmlTitle(a.tooltip) + DQ);
+function memberEdgeGids(g, ctx) {
+  const edges = [];
+  for (const [, n] of g.nodes) {
+    for (const e of n.outEdges(g)) {
+      if (ctx.edgeGid.has(e)) edges.push(e);
+    }
+  }
+  edges.sort((a, b) => a.seq - b.seq);
+  return edges.map((e) => ctx.edgeGid.get(e));
 }
-function mapOutputCmapx(shape, pts, a, isXml, out) {
-  out.push("<area shape=" + DQ + cmapxShape(shape) + DQ);
-  mapCmapxAttrs(a, out);
-  out.push(" alt=" + DQ + DQ);
-  out.push(" coords=" + DQ + cmapxCoords(shape, pts) + DQ);
-  out.push(isXml ? "/>\n" : ">\n");
+function buildEdgesArray(g, ctx) {
+  const edges = canonicalRootEdges(g).map(({ e }) => e);
+  edges.sort((a, b) => a.seq - b.seq);
+  return edges.map((e) => buildEdgeObject(e, ctx));
 }
-function mapOutputImap(shape, pts, url, out) {
-  if (!url) return;
-  if (shape === 0 /* Rectangle */) {
-    out.push("rect " + url + " " + Math.round(pts[0].x) + "," + Math.round(pts[1].y) + " " + Math.round(pts[1].x) + "," + Math.round(pts[0].y) + "\n");
-  } else if (shape === 1 /* Circle */) {
-    const r = Math.round(pts[1].x - pts[0].x);
-    out.push("circle " + url + " " + Math.round(pts[0].x) + "," + Math.round(pts[0].y) + "," + String(r) + "\n");
+function buildGraphObject(g, top, ctx) {
+  const o = {};
+  o.name = g.name;
+  if (top) {
+    o.directed = g.kind === "directed" || g.kind === "strict-directed";
+    o.strict = g.kind === "strict-directed" || g.kind === "strict-undirected";
+  }
+  const overlay = top ? ctx.draws?.graph : ctx.draws?.cluster.get(g);
+  emitAttrs(o, graphEffectiveAttrs(g, top), overlay, ctx);
+  attachGraphLabelGeom(o, g);
+  if (ctx.graphLabelDeclared && !("label" in o)) o.label = "";
+  if (top) {
+    o._subgraph_cnt = ctx.sgcnt;
   } else {
-    const pairs = pts.map((p) => Math.round(p.x) + "," + Math.round(p.y)).join(" ");
-    out.push("poly " + url + " " + pairs + "\n");
+    o._gvid = ctx.subgGid.get(g);
+  }
+  if (top) {
+    if (ctx.dfsSubs.length > 0 || g.nodes.size > 0) {
+      const objects = [];
+      for (const sg of ctx.dfsSubs) objects.push(buildGraphObject(sg, false, ctx));
+      for (const [, n] of g.nodes) objects.push(buildNodeObject(n, ctx));
+      o.objects = objects;
+    }
+  } else {
+    const childGids = [];
+    for (const [, sg] of g.subgraphs) childGids.push(ctx.subgGid.get(sg));
+    if (childGids.length > 0) o.subgraphs = childGids;
+    const nodeGids = [];
+    for (const [, n] of g.nodes) {
+      const gid = ctx.nodeGid.get(n);
+      if (gid !== void 0) nodeGids.push(gid);
+    }
+    if (nodeGids.length > 0) o.nodes = nodeGids;
+    const eGids = memberEdgeGids(g, ctx);
+    if (eGids.length > 0) o.edges = eGids;
+  }
+  if (top) {
+    const edges = buildEdgesArray(g, ctx);
+    if (edges.length > 0) o.edges = edges;
   }
+  return o;
 }
-var PlainRenderer = class {
-  type = "plain";
+function latin1Reencode(s) {
+  const bytes = new TextEncoder().encode(s);
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
+function buildJson(g, doXDot) {
+  const draws = doXDot ? collectDrawLookup(g) : void 0;
+  const ctx = assignIds(g, doXDot, draws);
+  const root = buildGraphObject(g, true, ctx);
+  return JSON.stringify(root, null, 2) + "\n";
+}
+var Json0Renderer = class {
+  type = "json0";
+  /** @see plugin/core/gvplugin_core.c registration table */
   quality = 0;
   beginGraph(_g, _job) {
   }
   endGraph(g, job) {
-    writePlain(g, job, false);
+    job.write(buildJson(g, false));
   }
   beginNode(_n, _job) {
   }
@@ -52433,13 +53052,14 @@ var PlainRenderer = class {
   polyline(_pts, _job) {
   }
 };
-var PlainExtRenderer = class {
-  type = "plain-ext";
+var JsonRenderer = class {
+  type = "json";
+  /** @see plugin/core/gvplugin_core.c registration table */
   quality = 0;
   beginGraph(_g, _job) {
   }
   endGraph(g, job) {
-    writePlain(g, job, true);
+    job.write(buildJson(g, true));
   }
   beginNode(_n, _job) {
   }
@@ -52460,183 +53080,11 @@ var PlainExtRenderer = class {
   polyline(_pts, _job) {
   }
 };
-function mapGraphName(g) {
-  return g.anonymous ? "%1" : g.name;
-}
-function graphAttr2(g, key) {
-  for (let s = g; s !== null; s = s.parent) {
-    const v = s.attrs.get(key);
-    if (v !== void 0 && v !== "") return v;
-  }
-  return void 0;
-}
-function graphMapUrl(g) {
-  const raw = graphAttr2(g, "href") ?? graphAttr2(g, "URL");
-  return raw === void 0 ? null : substObjAnchor(raw, g);
-}
-function buildMapCtx(g, job, mapPolygon) {
-  const drawingDpi = lateDouble(g.attrs.get("dpi"), lateDouble(g.attrs.get("resolution"), 0, 0), 0);
-  const mapDpi = drawingDpi > 0 ? drawingDpi : 96;
-  const devscale = mapDpi / POINTS_PER_INCH;
-  const z = initJobViewportZoom(job.bb, parseDrawingSize(g.attrs.get("size")), job.pad);
-  const marginOff = { x: job.margin.x * devscale, y: job.margin.y * devscale };
-  return { bb: job.bb, pad: job.pad, scale: z * devscale, marginOff, mapPolygon };
-}
-function anchorOf(url, tooltip, target, id) {
-  return { url: url ?? "", tooltip: tooltip ?? "", target: target ?? "", id: id ?? "" };
-}
-var MapRendererBase = class {
-  quality = 0;
-  mapCtx = null;
-  beginGraph(g, job) {
-    job.flags |= EMIT_CLUSTERS_LAST;
-    this.mapCtx = buildMapCtx(g, job, this.mapPolygon);
-    if (this.isCmapx) {
-      const name = escapeXml(mapGraphName(g));
-      job.write("<map id=" + DQ + name + DQ + " name=" + DQ + name + DQ + ">\n");
-      return;
-    }
-    job.write("base referer\n");
-    const url = graphMapUrl(g);
-    if (url) job.write("default " + url + "\n");
-  }
-  endGraph(_g, job) {
-    if (!this.isCmapx) return;
-    const obj = job.obj;
-    if (obj !== null && this.mapCtx !== null && (obj.url !== null || obj.explicitTooltip)) {
-      computeGraphUrlMap(obj, this.mapCtx);
-    }
-    const buf = [];
-    writeCmapxGraphShape(job, buf);
-    job.write(buf.join(""));
-    job.write("</map>\n");
-  }
-  beginNode(n, job) {
-    if (this.mapCtx !== null && job.obj !== null) computeNodeUrlMap(n, job.obj, this.mapCtx);
-  }
-  beginCluster(sg, job) {
-    const bb = sg.info.bb;
-    if (this.mapCtx !== null && job.obj !== null && bb !== void 0) {
-      computeClusterUrlMap(bb, job.obj, this.mapCtx);
-    }
-  }
-  endEdge(e, job) {
-    if (this.mapCtx !== null && job.obj !== null) this.emitEdge(e, job.obj, job);
-  }
-  /** C emit_map_rect: record the HTML table/cell box as the pending hot spot,
-   *  so the following beginAnchor emits its <area>. @see emit.c:640 */
-  emitMapRect(box, job) {
-    if (this.mapCtx !== null && job.obj !== null) {
-      computeClusterUrlMap(box, job.obj, this.mapCtx);
-    }
-  }
-  beginAnchor(url, tip2, target, id, job) {
-    const obj = job.obj;
-    if (obj === null || obj.urlMapPts.length === 0) return;
-    this.emitShape(obj.urlMapShape, obj.urlMapPts, { url, tooltip: tip2, target, id }, job);
-  }
-  endNode(_n, _job) {
-  }
-  beginEdge(_e, _job) {
-  }
-  endCluster(_sg, _job) {
-  }
-  textspan(_pos, _span, _job) {
-  }
-  ellipse(_c, _rx, _ry, _f, _j) {
-  }
-  polygon(_pts, _filled, _job) {
-  }
-  bezier(_pts, _filled, _job) {
-  }
-  polyline(_pts, _job) {
-  }
-  /** Emit one hot spot: `<area>` (cmapx) or a plain `keyword url coords` line. */
-  emitShape(shape, pts, a, job) {
-    const buf = [];
-    if (this.isCmapx) mapOutputCmapx(shape, pts, a, true, buf);
-    else mapOutputImap(shape, pts, a.url, buf);
-    job.write(buf.join(""));
-  }
-  /** Whole-edge spline outline(s) then center/head/tail label hot spots.
-   * @see lib/common/emit.c:emit_begin_edge (2851-2872) / emit_end_edge */
-  emitEdge(e, obj, job) {
-    const spl = e.info.spl;
-    const wholeEdge = obj.url !== null || obj.explicitTooltip;
-    if (spl !== void 0 && this.mapPolygon && wholeEdge) {
-      const w2 = Math.max(obj.penWidth / 2, 2);
-      const anchor = anchorOf(obj.url, obj.tooltip, obj.target, obj.id);
-      for (const poly of computeEdgeSplineMaps(spl, w2, this.mapCtx)) {
-        this.emitShape(2 /* Polygon */, poly, anchor, job);
-      }
-    }
-    const centerA = {
-      url: obj.labelUrl,
-      tooltip: obj.labelTooltip,
-      target: obj.labelTarget,
-      explicit: obj.explicitLabelTooltip
-    };
-    this.emitEdgeLabel(e.info.label, centerA, obj, job);
-    this.emitEdgeLabel(e.info.xlabel, centerA, obj, job);
-    this.emitEdgeLabel(
-      e.info.head_label,
-      { url: obj.headUrl, tooltip: obj.headTooltip, target: obj.headTarget, explicit: obj.explicitHeadTooltip },
-      obj,
-      job
-    );
-    this.emitEdgeLabel(
-      e.info.tail_label,
-      { url: obj.tailUrl, tooltip: obj.tailTooltip, target: obj.tailTarget, explicit: obj.explicitTailTooltip },
-      obj,
-      job
-    );
-  }
-  /** One edge label hot spot (map_label rect), if placed and url/explicit-tip.
-   * @see lib/common/emit.c:emit_edge_label */
-  emitEdgeLabel(lab, la, obj, job) {
-    const placed = lab !== void 0 && lab.set && this.mapCtx !== null;
-    if (!placed || la.url === null && !la.explicit) return;
-    computeLabelRectMap(lab, obj, this.mapCtx);
-    this.emitShape(0 /* Rectangle */, obj.urlMapPts, anchorOf(la.url, la.tooltip, la.target, obj.id), job);
-  }
-};
-var ImapRenderer = class extends MapRendererBase {
-  type = "imap";
-  isCmapx = false;
-  mapPolygon = true;
-};
-var ImapNpRenderer = class extends MapRendererBase {
-  type = "imap-np";
-  isCmapx = false;
-  mapPolygon = false;
-};
-var CmapxRenderer = class extends MapRendererBase {
-  type = "cmapx";
-  isCmapx = true;
-  mapPolygon = true;
-};
-var CmapxNpRenderer = class extends MapRendererBase {
-  type = "cmapx-np";
-  isCmapx = true;
-  mapPolygon = false;
-};
-function createPlainRenderer() {
-  return new PlainRenderer();
-}
-function createPlainExtRenderer() {
-  return new PlainExtRenderer();
-}
-function createImapRenderer() {
-  return new ImapRenderer();
-}
-function createImapNpRenderer() {
-  return new ImapNpRenderer();
-}
-function createCmapxRenderer() {
-  return new CmapxRenderer();
+function createJson0Renderer() {
+  return new Json0Renderer();
 }
-function createCmapxNpRenderer() {
-  return new CmapxNpRenderer();
+function createJsonRenderer() {
+  return new JsonRenderer();
 }
 
 // src/gvc/default-context.ts