@knowvah/dot-engine 2.7.0 → 2.8.0

package/dist/index.js

@@ -17,7 +17,9 @@ var WHITESPACE = /* @__PURE__ */ new Set([9, 10, 11, 12, 13]);
 var OCTAL_WIDTH = 3;
 var OCTAL_RADIX = 8;
 var lastLevel = "warning";
+var pending = { line: null, channel: "warn" };
 registerRenderState(() => {
+  flushPending();
   lastLevel = "warning";
 });
 function escapeControl(message) {
@@ -31,17 +33,43 @@ function escapeControl(message) {
   return out;
 }
 function agerrLineOn(channel, line) {
+  flushPending();
+  writeLine(channel, line);
+}
+function flushPending() {
+  if (pending.line === null) return;
+  const { line, channel } = pending;
+  pending.line = null;
+  writeLine(channel, line);
+}
+function writeLine(channel, line) {
   if (channel === "warn") console.warn(escapeControl(line));
   else console.error(escapeControl(line));
 }
-function agerr(level, msg, channel) {
-  if (level === "prev") {
-    agerrLineOn(channel ?? (lastLevel === "warning" ? "warn" : "error"), msg);
-    return;
-  }
-  lastLevel = level;
+function assemble(level, msg) {
+  if (level === "prev") return msg;
   const prefix = level === "error" ? PREFIX_ERROR : PREFIX_WARNING;
-  agerrLineOn(channel ?? (level === "warning" ? "warn" : "error"), `${prefix}${PREFIX_SEP}${msg}`);
+  return `${prefix}${PREFIX_SEP}${msg}`;
+}
+function channelOf(level) {
+  const eff = level === "prev" ? lastLevel : level;
+  return eff === "warning" ? "warn" : "error";
+}
+function emit(level, msg, channel, hold) {
+  const target = channel ?? channelOf(level);
+  if (level !== "prev") lastLevel = level;
+  const text = assemble(level, msg);
+  if (pending.line === null) {
+    pending.channel = target;
+    pending.line = text;
+  } else pending.line += text;
+  if (!hold) flushPending();
+}
+function agerr(level, msg, channel) {
+  emit(level, msg, channel, false);
+}
+function agerrPartial(level, msg, channel) {
+  emit(level, msg, channel, true);
 }
 var agerrorf = (msg, channel) => agerr("error", msg, channel);
 var agwarningf = (msg, channel) => agerr("warning", msg, channel);
@@ -3989,6 +4017,10 @@ var Edge = class _Edge {
 
 // src/model/cgraph-ops.ts
 var LOCALNAMEPREFIX = "%";
+var ANONYMOUS_ROOT_ID = 1;
+function agNameOf(g) {
+  return g.anonymous ? `${LOCALNAMEPREFIX}${ANONYMOUS_ROOT_ID}` : g.name;
+}
 function freshNodeId(root) {
   let max = -1;
   for (const n of root.nodes.values()) {
@@ -8824,6 +8856,7 @@ function claimWarned() {
   return true;
 }
 var claimNever = () => false;
+var MSG_MANY_COLORS = "More than 2 colors specified for a gradient - ignoring remaining";
 var EPS = 1e-5;
 function aeq0(x) {
   return x < EPS && x > -EPS;
@@ -8889,8 +8922,8 @@ function scanSegs(colorlist, claim) {
 function parseSegs(colorlist, context) {
   const result = scanSegs(colorlist, claimWarned);
   if (result.error === 3) {
-    const tail = context === void 0 ? "" : context();
-    agwarningf(`Total size > 1 in "${colorlist}" color spec ${tail}`);
+    agerrPartial("warning", `Total size > 1 in "${colorlist}" color spec `);
+    if (context !== void 0) agerr("prev", context());
   } else if (result.error === 2) {
     agerrorf(`Illegal value in "${colorlist}" color attribute; float expected after ';'`);
     if (context !== void 0) agerr("prev", context());
@@ -8940,23 +8973,68 @@ function zeroFlags() {
   };
 }
 var FUNLIMIT = 64;
+var STYLE_SPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\v", "\f", "\r"]);
+function isStyleDelim(c) {
+  return c === void 0 || c === "(" || c === ")" || c === ",";
+}
+function styleToken(s, from) {
+  let p = from;
+  while (p < s.length && (STYLE_SPACE.has(s[p]) || s[p] === ",")) p++;
+  if (p >= s.length) return null;
+  if (s[p] === "(" || s[p] === ")") return { type: s[p], text: s[p], next: p + 1 };
+  const start = p;
+  while (!isStyleDelim(s[p])) p++;
+  return { type: "id", text: s.slice(start, p), next: p };
+}
+var NO_TOKENS = [];
+function parseStyleQuiet(s) {
+  const end = s.indexOf("\0");
+  const str = end < 0 ? s : s.slice(0, end);
+  const names = [];
+  const args = [];
+  let inParens = false;
+  for (let c = styleToken(str, 0); c !== null; c = styleToken(str, c.next)) {
+    if (c.type === "(") {
+      if (inParens) return { tokens: NO_TOKENS, fault: "nesting" };
+      inParens = true;
+    } else if (c.type === ")") {
+      if (!inParens) return { tokens: NO_TOKENS, fault: "unmatched-close" };
+      inParens = false;
+    } else if (inParens) {
+      args[names.length - 1]?.push(c.text);
+    } else {
+      if (names.length === FUNLIMIT - 1) return { tokens: NO_TOKENS, fault: "truncate" };
+      names.push(c.text);
+      args.push([]);
+    }
+  }
+  if (inParens) return { tokens: NO_TOKENS, fault: "unmatched-open" };
+  const tokens = names.map((n, i) => args[i].length === 0 ? n : `${n}(${args[i].join(",")})`);
+  return { tokens, fault: null };
+}
+function reportStyleFault(fault, s) {
+  if (fault === "nesting") agerrorf(`nesting not allowed in style: ${s}`);
+  else if (fault === "unmatched-close") agerrorf(`unmatched ')' in style: ${s}`);
+  else if (fault === "unmatched-open") agerrorf(`unmatched '(' in style: ${s}`);
+  else agwarningf(`truncating style '${s}'`);
+}
 function styleTokens(style2) {
   if (!style2) return [];
-  const out = [];
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return [];
-    fun++;
-    out.push(token);
-  }
-  return out;
+  const { tokens, fault } = parseStyleQuiet(style2);
+  if (fault !== null) reportStyleFault(fault, style2);
+  return tokens;
+}
+function styleTokensQuiet(style2) {
+  return style2 ? parseStyleQuiet(style2).tokens : [];
+}
+function styleName(token) {
+  const paren = token.indexOf("(");
+  return paren < 0 ? token : token.slice(0, paren);
 }
 function parseSetLineWidth(token) {
-  const m = /^setlinewidth\s*\(\s*([^)]*)\)\s*$/.exec(token);
-  if (m === null) return null;
-  const v = parseFloat(m[1]);
+  if (styleName(token) !== "setlinewidth") return null;
+  const m = /^[^(]*\(([^,)]*)/.exec(token);
+  const v = m === null ? Number.NaN : parseFloat(m[1]);
   return Number.isNaN(v) ? 0 : v;
 }
 function applyToken(flags, token) {
@@ -8980,33 +9058,18 @@ function firstSolidColor(raw) {
 }
 function parseStyleFlags(style2) {
   const flags = zeroFlags();
-  if (!style2) return flags;
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return zeroFlags();
-    fun++;
+  for (const token of styleTokensQuiet(style2)) {
     const lw = parseSetLineWidth(token);
     if (lw !== null) {
       flags.setLineWidth = lw;
       continue;
     }
-    if (!token.includes("(")) applyToken(flags, token);
+    applyToken(flags, styleName(token));
   }
   return flags;
 }
 function styleHasInvisibleAlias(style2) {
-  if (!style2) return false;
-  let fun = 0;
-  for (const raw of style2.split(",")) {
-    const token = raw.trim();
-    if (token.length === 0) continue;
-    if (fun === FUNLIMIT - 1) return false;
-    fun++;
-    if (token === "invisible") return true;
-  }
-  return false;
+  return styleTokensQuiet(style2).some((token) => styleName(token) === "invisible");
 }
 function resolvePenType(flags) {
   if (flags.invis) return 0 /* None */;
@@ -9044,11 +9107,10 @@ function applyBgcolor(attrs, filled, fillcolor) {
 }
 function findStopColor(colorlist) {
   const { segs, error } = parseSegs(colorlist);
-  if (error === 1 || error === 2) return null;
-  if (segs.length < 2) return null;
   const seg0 = segs[0];
   const seg1 = segs[1];
-  if (seg0.color === null) return null;
+  if (error !== 0 || seg0 === void 0 || seg1 === void 0 || seg0.color === null) return null;
+  if (segs.length > 2) agwarningf(MSG_MANY_COLORS);
   const fillColor = seg0.color;
   const stopColor = seg1.color ?? DEFAULT_COLOR;
   const frac = seg0.hasFraction ? seg0.t : seg1.hasFraction ? 1 - seg1.t : 0;
@@ -9061,7 +9123,7 @@ function parseAngle(gradientangle2) {
 }
 function buildResolvedFill(rawColor, flags, angle) {
   const stop = findStopColor(rawColor);
-  if (stop === null) return { kind: "solid", color: rawColor };
+  if (stop === null) return { kind: "solid", color: rawColor.split(":", 1)[0] };
   const kind = flags.radial ? "radial" : "linear";
   return { kind, fillColor: stop.fillColor, stopColor: stop.stopColor, frac: stop.frac, angle };
 }
@@ -9256,6 +9318,13 @@ function firstColor(name) {
 }
 function resolveRenderColor(raw, report = true) {
   if (raw === "" || raw === "none") return { type: "none" };
+  return resolveColorName(raw, report);
+}
+function resolveFillColorName(raw, report = true) {
+  if (raw === "none") return { type: "none" };
+  return resolveColorName(raw, report);
+}
+function resolveColorName(raw, report) {
   const known = KNOWN_COLORS.has(raw.toLowerCase());
   if (known && (rendererColors.hasKnownList || !report)) return { type: "string", s: raw };
   const color = { type: "rgba", r: 0, g: 0, b: 0, a: 0 };
@@ -9369,7 +9438,7 @@ function reportEdgeColors(e) {
   reportColorNames(edgeGraphicsColors({
     color,
     fillcolor: e.attrs.get("fillcolor") ?? "",
-    tapered: styleTokens(e.attrs.get("style")).includes("tapered"),
+    tapered: styleTokensQuiet(e.attrs.get("style")).includes("tapered"),
     arrows: spl.list.map((bz) => ({ sflag: bz.sflag !== 0, eflag: bz.eflag !== 0 }))
   }));
 }
@@ -9929,10 +9998,6 @@ var BOX_ORIENTATION_TOLERANCE = 0.5;
 var BOX_ORIENTATION_STEP = 90;
 var BOX_SIDES = 4;
 var ELLIPSE_MAX_SIDES = 2;
-function styleName(token) {
-  const paren = token.indexOf("(");
-  return paren < 0 ? token : token.slice(0, paren);
-}
 function gvrenderSetStyle(styles) {
   if (styles === null) return;
   for (const token of styles) {
@@ -9996,7 +10061,6 @@ var BORDER_BOTTOM = 1 << 13;
 var BORDER_MASK = BORDER_LEFT | BORDER_TOP | BORDER_RIGHT | BORDER_BOTTOM;
 
 // src/common/htmltable-emit-fill.ts
-var MSG_MANY_COLORS = "More than 2 colors specified for a gradient - ignoring remaining";
 function findHtmlStopColor(color, silent = false) {
   const { segs, error } = silent ? parseSegsSilent(color) : parseSegs(color);
   const first = segs[0];
@@ -10080,7 +10144,7 @@ function penTypeOf(style2) {
   return 3 /* Solid */;
 }
 function withHtmlPaint(paint, job, drawFn) {
-  paintObj.fillColor = paint.fill !== void 0 ? resolveRenderColor(firstColor(paint.fill)) : { type: "none" };
+  paintObj.fillColor = paint.fill !== void 0 ? resolveFillColorName(firstColor(paint.fill)) : { type: "none" };
   paintObj.penColor = paint.pen !== void 0 ? resolveRenderColor(paint.pen) : { type: "string", s: "transparent" };
   applyHtmlFill(paint);
   paintObj.pen = penTypeOf(paint.penStyle);
@@ -10205,7 +10269,9 @@ function emitSidedPolylines(sides2, corners, renderer, job) {
 var HTML_DEFAULT_COLOR = "black";
 function bgNames(bgcolor) {
   const spec = parseGradientSpec(bgcolor);
-  return spec === null ? [bgcolor] : [spec[0], spec[1]];
+  if (spec !== null) return [spec[0], spec[1]];
+  if (parseSegsSilent(bgcolor).error !== 0 || firstColor(bgcolor) === "") return [];
+  return [bgcolor];
 }
 function cellNames(cell2) {
   if (htmlStyle(cell2.style).invisible) return [];
@@ -10518,6 +10584,17 @@ function emitHtmlLabel(placed, pos, renderer, job) {
   }
 }
 
+// src/common/attr-get.ts
+function nodeAttr(n, g, key) {
+  const own = n.attrs.get(key);
+  if (own !== void 0) return own;
+  if (n.nodeDefaultsSnapshot !== void 0) return n.nodeDefaultsSnapshot.get(key);
+  return g.nodeDefaults.get(key) ?? (g !== g.root ? g.root.nodeDefaults.get(key) : void 0);
+}
+function graphAttrInherited(sg, key) {
+  return sg.attrs.get(key) ?? sg.graphDefaultsSnapshot?.get(key);
+}
+
 // src/common/htmltable-attr-warn.ts
 var accepted = (v) => ({ keep: v, text: [], warn: false });
 var ignored = (text) => ({ keep: void 0, text: [text], warn: true });
@@ -10689,8 +10766,8 @@ function checkAttrs(tag, pairs) {
   return { attrs, warnings, warn };
 }
 var StderrLines = class {
-  constructor(writeLine) {
-    this.writeLine = writeLine;
+  constructor(writeLine2) {
+    this.writeLine = writeLine2;
   }
   writeLine;
   pending = "";
@@ -11044,6 +11121,15 @@ var NAME_CHAR = /[\w.:\u0080-
 var DEC_DIGIT = /[0-9]/;
 var HEX_DIGIT = /[0-9A-Fa-f]/;
 var NON_XML = /[\x00-\x08\x0b\x0c\x0e-\x1f]/;
+var NON_XML_BEYOND_ASCII = /[\ufffe\uffff]/;
+var HIGH_SURROGATE = /[\ud800-\udbff]/;
+var LOW_SURROGATE = /[\udc00-\udfff]/;
+function isNonXmlAt(text, k) {
+  const c = text[k];
+  if (NON_XML.test(c) || NON_XML_BEYOND_ASCII.test(c)) return true;
+  if (HIGH_SURROGATE.test(c)) return !LOW_SURROGATE.test(text[k + 1] ?? "");
+  return LOW_SURROGATE.test(c) && !HIGH_SURROGATE.test(text[k - 1] ?? "");
+}
 function scanDigits(text, i, digit) {
   if (i >= text.length) return { partial: true };
   if (!digit.test(text[i])) return { invalid: i };
@@ -11071,7 +11157,7 @@ function scanAttValue(text, j) {
     const c = text[k];
     if (c === void 0) return { partial: true };
     if (c === q) return { close: k };
-    if (c === "<" || NON_XML.test(c)) return { invalid: k };
+    if (c === "<" || isNonXmlAt(text, k)) return { invalid: k };
     if (c !== "&") {
       k++;
       continue;
@@ -12369,6 +12455,26 @@ function imageIsSupplied(name, sizer, resolver) {
 function imageOpenWarning(name) {
   return `${STRERROR_ENOENT} while opening ${name}`;
 }
+var DEFAULT_DPI = 96;
+var POINTS_PER_INCH2 = 72;
+function usershapeDpi(attrs) {
+  const lateDouble2 = (s, dflt) => {
+    if (s === void 0 || s === "") return dflt;
+    const v = Number(s);
+    return Number.isNaN(v) || s.trim() === "" ? dflt : Math.max(v, 0);
+  };
+  const dpi = lateDouble2(attrs.get("dpi"), lateDouble2(attrs.get("resolution"), 0));
+  return dpi >= 1 ? dpi : DEFAULT_DPI;
+}
+function usershapeSizePts(name, dpi, sizer) {
+  if (name === void 0 || name === "") return null;
+  const px = sizer !== void 0 ? sizer(name) : findImageSize(name);
+  if (px === null) return null;
+  return {
+    x: Math.trunc(px.w * POINTS_PER_INCH2 / dpi),
+    y: Math.trunc(px.h * POINTS_PER_INCH2 / dpi)
+  };
+}
 
 // src/common/pointset.ts
 function cmpPair(a, b) {
@@ -17395,7 +17501,7 @@ function splitFamilies(fontname) {
 function aliasFamilies(a) {
   return a.svgFontFamily !== a.family ? [a.family, a.svgFontFamily] : [a.family];
 }
-function styleToken(a, flags) {
+function styleToken2(a, flags) {
   if (a?.style != null) return a.style;
   return flags?.italic === true ? "italic" : null;
 }
@@ -17404,7 +17510,7 @@ function weightToken(a, flags) {
   return flags?.bold === true ? "bold" : null;
 }
 function variantTokens(a, flags) {
-  const tokens = [styleToken(a, flags), weightToken(a, flags), a?.stretch ?? null];
+  const tokens = [styleToken2(a, flags), weightToken(a, flags), a?.stretch ?? null];
   return tokens.filter((t) => t !== null);
 }
 function canvasFont(fontname, fontsize, flags) {
@@ -17818,15 +17924,15 @@ var sizeTextContent = (texts, measurer, env = defaultSizeEnv()) => {
   return { w, h };
 };
 var missingImages = { set: /* @__PURE__ */ new WeakSet() };
-var sizeHtmlImg = (img, { imageSizer, stderr }) => {
+var sizeHtmlImg = (img, { imageSizer, imageResolver, imageDpi, stderr }) => {
   if (img.width !== void 0 && img.height !== void 0) return missingImages.set.has(img) ? 1 : 0;
-  const sz = imageSizer !== void 0 ? imageSizer(img.src) : findImageSize(img.src);
+  const sz = usershapeSizePts(img.src, imageDpi ?? DEFAULT_DPI, imageSizer);
   if (sz !== null) {
-    img.width = sz.w;
-    img.height = sz.h;
+    img.width = sz.x;
+    img.height = sz.y;
     return 0;
   }
-  if (!imageIsSupplied(img.src, imageSizer)) agerrLine(stderr, `Warning: ${imageOpenWarning(img.src)}`);
+  if (!imageIsSupplied(img.src, imageSizer, imageResolver)) agerrLine(stderr, `Warning: ${imageOpenWarning(img.src)}`);
   agerrLine(stderr, `Error: No or improper image file="${img.src}"`);
   img.width = 0;
   img.height = 0;
@@ -18313,7 +18419,7 @@ function posHtmlLabel(label, finfo, measurer) {
 // src/common/htmltable-label.ts
 var HTML_PARSE_FATAL = 3;
 function makeHtmlLabelTo(content, finfo, measurer, stderr) {
-  const { fontname, fontsize, fontcolor, imageSizer, pencolor } = finfo;
+  const { fontname, fontsize, fontcolor, imageSizer, imageResolver, imageDpi, pencolor } = finfo;
   let lbl, lexWarn;
   try {
     ({ label: lbl, warn: lexWarn } = parseHtmlLabelRv(content, stderr));
@@ -18327,6 +18433,8 @@ function makeHtmlLabelTo(content, finfo, measurer, stderr) {
     fontsize,
     fontname,
     imageSizer,
+    imageResolver,
+    imageDpi,
     stderr
   });
   const placed = posHtmlLabel(lbl, { fontname, fontsize, fontcolor }, measurer);
@@ -18445,12 +18553,17 @@ var DEFAULT_FONTNAME = "Times-Roman";
 var DEFAULT_COLOR3 = "black";
 function getPenColor(obj) {
   if (obj === void 0) return void 0;
-  const pc = obj.attrs.get("pencolor");
+  const pc = aggetObj(obj, "pencolor");
   if (pc !== void 0 && pc !== "") return pc;
-  const c = obj.attrs.get("color");
+  const c = aggetObj(obj, "color");
   if (c !== void 0 && c !== "") return c;
   return void 0;
 }
+function aggetObj(obj, key) {
+  if (obj instanceof Node) return nodeAttr(obj, obj.root, key);
+  if (obj instanceof Graph) return graphAttrInherited(obj, key);
+  return obj.attrs.get(key);
+}
 function rootOf(obj) {
   return obj instanceof Edge ? obj.tail.root : obj.root;
 }
@@ -18528,9 +18641,12 @@ function makeLabel(text, fontname, fontsize, fontcolor, measurer) {
 }
 function makeAnyLabel(content, isHtml, font, measurer, obj) {
   if (isHtml && content !== "") {
-    const imageSizer = obj !== void 0 ? rootOf(obj).info.gvc?.imageSizer : void 0;
+    const root = obj !== void 0 ? rootOf(obj) : void 0;
+    const imageSizer = root?.info.gvc?.imageSizer;
+    const imageResolver = root?.info.gvc?.imageResolver;
+    const imageDpi = root !== void 0 ? usershapeDpi(root.attrs) : void 0;
     const stderr = labelStderr();
-    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer }, measurer, stderr);
+    const { label, rv } = makeHtmlLabelTo(content, { ...font, pencolor: getPenColor(obj), imageSizer, imageResolver, imageDpi }, measurer, stderr);
     if (rv !== 0 && obj !== void 0) stderr.write(`${inLabelOf(obj)}
 `);
     stderr.flush();
@@ -18701,6 +18817,9 @@ function computeVertices(poly, w, h, base) {
 var SPLIT = 134217729;
 function fma(a, b, c) {
   const p = a * b;
+  if (!Number.isFinite(p) || !Number.isFinite(c)) {
+    return Number.isFinite(a) && Number.isFinite(b) && !Number.isFinite(c) ? c : p + c;
+  }
   const at = SPLIT * a;
   const ahi = at - (at - a);
   const alo = a - ahi;
@@ -19001,7 +19120,8 @@ function polySize(p) {
   const init = initialSizePts(p);
   const dimen = quantize(padLabelDimen(p.labelDimen, p.margin, p.isPlain), p.quantumIn);
   const { sides: sides2, isBox: isBox4 } = effectiveShape(p);
-  let bb = { x: dimen.x, y: dimen.y };
+  const img = p.imageSize ?? { x: 0, y: 0 };
+  let bb = { x: Math.max(dimen.x, img.x), y: Math.max(dimen.y, img.y) };
   if (isBox4) {
   } else if (p.optionShape === STAR) {
     bb = starSize(bb);
@@ -19030,7 +19150,7 @@ function labelSpace(p, dimen, bb, minBb, isBox4, fixedshape) {
   } else {
     spaceX = dimen.x - spacex;
   }
-  const spaceY = fixedshape ? dimen.y : dimen.y + (bb.y - minBb.y);
+  const spaceY = fixedshape ? dimen.y : dimen.y + (bb.y - minBb.y + Math.max(0, (p.imageSize?.y ?? 0) - dimen.y));
   return { space: { x: spaceX, y: spaceY }, valign: labelValign(p) };
 }
 function effectiveShape(p) {
@@ -21168,9 +21288,6 @@ function readLabelPos(sg) {
   }
   return pos;
 }
-function graphAttrInherited(sg, key) {
-  return sg.attrs.get(key) ?? sg.graphDefaultsSnapshot?.get(key);
-}
 function readFontParams(sg) {
   return {
     fontsize: parseFloat(graphAttrInherited(sg, "fontsize") ?? "") || DEFAULT_FONTSIZE2,
@@ -25094,12 +25211,6 @@ function drawRecordBox(job, n, ll, ur, filled) {
 var DEFAULT_LW = 27;
 var DEFAULT_RW = 27;
 var DEFAULT_HT = 36;
-function nodeAttr(n, g, key) {
-  const own = n.attrs.get(key);
-  if (own !== void 0) return own;
-  if (n.nodeDefaultsSnapshot !== void 0) return n.nodeDefaultsSnapshot.get(key);
-  return g.nodeDefaults.get(key) ?? (g !== g.root ? g.root.nodeDefaults.get(key) : void 0);
-}
 function readFontAttrs(n, g) {
   return {
     fontname: nodeAttr(n, g, "fontname") ?? DEFAULT_FONTNAME,
@@ -25133,6 +25244,15 @@ function warnMissingImage(n, g, shapefile) {
   agwarningf(imageOpenWarning(image));
   agwarningf(`No or improper image="${image}" for node "${n.name}"`);
 }
+function nodeImageSize(n, g) {
+  const shapefile = nodeAttr(n, g, "shapefile");
+  if (shapefile !== void 0 && shapefile !== "") return void 0;
+  const gvc = g.root.info.gvc;
+  const sz = usershapeSizePts(nodeAttr(n, g, "image"), usershapeDpi(g.root.attrs), gvc?.imageSizer);
+  if (sz === null) return void 0;
+  g.root.info.has_images = true;
+  return { x: sz.x + 2, y: sz.y + 2 };
+}
 function polyInit(n, g, measurer) {
   const shapeName2 = nodeAttr(n, g, "shape") ?? "ellipse";
   const shapefile = nodeAttr(n, g, "shapefile");
@@ -25492,11 +25612,7 @@ function applyClusterGradient(obj, fill) {
   obj.gradientAngle = fill.angle;
 }
 function clusterAttr(sg, key) {
-  for (let g = sg; g !== null; g = g.parent) {
-    const v = g.attrs.get(key);
-    if (v !== void 0) return v;
-  }
-  return void 0;
+  return graphAttrInherited(sg, key);
 }
 function clusterStyle(sg) {
   return clusterAttr(sg, "style");
@@ -25531,12 +25647,10 @@ function applyClusterObjState(sg, job) {
   if (job.obj === null) return false;
   const obj = job.obj;
   gvrenderSetStyle(checkClusterStyleTokens(styleTokens(clusterStyle(sg))));
-  return withColorScheme(clusterAttr(sg, "colorscheme"), () => {
-    const filled = applyClusterFill(obj, fillRes);
-    applyClusterPenState(obj, sg);
-    reportColorNames(stripedClusterColors(sg));
-    return filled;
-  });
+  const filled = applyClusterFill(obj, fillRes);
+  applyClusterPenState(obj, sg);
+  reportColorNames(stripedClusterColors(sg));
+  return filled;
 }
 function isStripedCluster(sg) {
   const flags = parseStyleFlags(clusterStyle(sg));
@@ -25557,27 +25671,25 @@ function stripedClusterColors(sg) {
   return segs.flatMap((seg2) => seg2.color !== null && seg2.t > 0 ? [seg2.color] : []);
 }
 function renderStripedClusterBox(sg, renderer, job) {
-  withColorScheme(clusterAttr(sg, "colorscheme"), () => {
-    const { ll, ur } = sg.info.bb;
-    const af = [
-      { x: ll.x, y: ll.y },
-      { x: ur.x, y: ll.y },
-      { x: ur.x, y: ur.y },
-      { x: ll.x, y: ur.y }
-    ].map((p) => transformPoint(p, job));
-    const obj = job.obj;
-    const savedFill = obj?.fill;
-    if (obj !== null && savedFill !== void 0) obj.fill = 1 /* Solid */;
-    stripedBox(job, af, stripedFillSpec(sg), false, renderer, () => `in cluster ${sg.name}`);
-    if (obj !== null && savedFill !== void 0) obj.fill = savedFill;
-    const rawPts = [
-      { x: ll.x, y: ll.y },
-      { x: ll.x, y: ur.y },
-      { x: ur.x, y: ur.y },
-      { x: ur.x, y: ll.y }
-    ];
-    renderer.polygon(rawPts.map((p) => transformPoint(p, job)), false, job);
-  });
+  const { ll, ur } = sg.info.bb;
+  const af = [
+    { x: ll.x, y: ll.y },
+    { x: ur.x, y: ll.y },
+    { x: ur.x, y: ur.y },
+    { x: ll.x, y: ur.y }
+  ].map((p) => transformPoint(p, job));
+  const obj = job.obj;
+  const savedFill = obj?.fill;
+  if (obj !== null && savedFill !== void 0) obj.fill = 1 /* Solid */;
+  stripedBox(job, af, stripedFillSpec(sg), false, renderer, () => `in cluster ${sg.name}`);
+  if (obj !== null && savedFill !== void 0) obj.fill = savedFill;
+  const rawPts = [
+    { x: ll.x, y: ll.y },
+    { x: ll.x, y: ur.y },
+    { x: ur.x, y: ur.y },
+    { x: ur.x, y: ll.y }
+  ];
+  renderer.polygon(rawPts.map((p) => transformPoint(p, job)), false, job);
 }
 function applyClusterFill(obj, fillRes) {
   if (fillRes.kind === "none") {
@@ -26318,7 +26430,24 @@ function removeFill(g) {
   }
   agdelsubg(g.root, sg);
 }
+function gvCleanupEdgeLabels(e) {
+  e.info.label = void 0;
+  e.info.xlabel = void 0;
+  e.info.head_label = void 0;
+  e.info.tail_label = void 0;
+}
+function gvCleanupNodeLabels(n) {
+  n.info.label = void 0;
+  n.info.xlabel = void 0;
+}
+function dotCleanupGraph(g) {
+  for (const subg of g.subgraphs.values()) dotCleanupGraph(subg);
+  if (g !== g.root) g.info.label = void 0;
+}
 function dotCleanup(g) {
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n2 of g.nodes.values()) gvCleanupNodeLabels(n2);
+  dotCleanupGraph(g);
   let n = g.info.nlist;
   while (n !== void 0) {
     const next = n.info.next;
@@ -26796,7 +26925,7 @@ var DEFAULT_NODEWIDTH = 0.75;
 var MIN_NODEWIDTH = 0.01;
 var DEFAULT_NODEHEIGHT = 0.5;
 var MIN_NODEHEIGHT = 0.02;
-var POINTS_PER_INCH2 = 72;
+var POINTS_PER_INCH3 = 72;
 var DEF_POINT = 0.05;
 var MIN_POINT = 3e-4;
 var DEFAULT_NODEPENWIDTH2 = 1;
@@ -26864,6 +26993,8 @@ function polySizeParamsFromNode(n, g, shape, labelDimen, flip) {
     // size_gen discriminant (STAR/CYLINDER)
     nojustify: mapbool4(nodeAttr(n, g, "nojustify")),
     // shapes.c:2133
+    imageSize: nodeImageSize(n, g),
+    // shapes.c:2039-2051
     flip
   };
 }
@@ -26900,7 +27031,7 @@ function initPointSize(n, g, shape) {
   const flip = g.root.info.flip === true;
   const peripheries = lateInt(nodeAttr(n, g, "peripheries"), shape.polygon.peripheries, 0);
   const penwidth = lateDouble(nodeAttr(n, g, "penwidth"), DEFAULT_NODEPENWIDTH2, MIN_NODEPENWIDTH);
-  const sz0 = pointWidthInches(n, g) * POINTS_PER_INCH2;
+  const sz0 = pointWidthInches(n, g) * POINTS_PER_INCH3;
   storeNodeSize(n, pointSizeResult(sz0, peripheries, penwidth), flip);
   assignShapeInfo(n, { ...shape.polygon, peripheries, sides: 2, penwidth, vertices: null });
 }
@@ -26957,8 +27088,8 @@ function storeNodeSize(n, unflipped, flip) {
   n.info.base_width = unflipped.baseW / 72;
   n.info.base_height = unflipped.baseH / 72;
   const size = gvNodesize(
-    n.info.width * POINTS_PER_INCH2,
-    n.info.height * POINTS_PER_INCH2,
+    n.info.width * POINTS_PER_INCH3,
+    n.info.height * POINTS_PER_INCH3,
     flip
   );
   n.info.lw = size.lw;
@@ -28540,10 +28671,13 @@ function parseLayers(g) {
   let listSep = g.attrs.get("layerlistsep") || DEFAULT_LAYERLISTSEP;
   if ([...sep].some((c) => listSep.includes(c))) listSep = "";
   if (p === void 0 || p === "") {
-    return { layerIDs: [], numLayers: 1, sep, listSep };
+    return { layerIDs: [], numLayers: 1, sep, listSep, layerList: null };
   }
   const toks = splitOnSet(p, sep);
-  return { layerIDs: [null, ...toks], numLayers: toks.length, sep, listSep };
+  const info = { layerIDs: [null, ...toks], numLayers: toks.length, sep, listSep, layerList: null };
+  const sel = g.attrs.get("layerselect");
+  if (sel !== void 0 && sel !== "") info.layerList = parseLayerselect(info, sel);
+  return info;
 }
 function isNaturalNumber(s) {
   return /^[0-9]+$/.test(s);
@@ -28599,6 +28733,19 @@ function edgeInLayer(info, layerNum, e) {
     return pn === "" || selectedLayer(info, layerNum, pn);
   });
 }
+function parseLayerselect(info, p) {
+  const picked = [];
+  for (let i = 1; i <= info.numLayers; i++) {
+    if (selectedLayer(info, i, p)) picked.push(i);
+  }
+  if (picked.length === 0) {
+    agwarningf(
+      `The layerselect attribute "${p}" does not match any layer specifed by the layers attribute - ignored.`
+    );
+    return null;
+  }
+  return [picked.length, ...picked, info.numLayers + 1];
+}
 
 // src/gvc/emit-walk.ts
 function nodeShown(info, job, n, g) {
@@ -28661,9 +28808,40 @@ var NATIVE_LANGNAME = /* @__PURE__ */ new Map([
   ["cmapx-np", "cmapx_np"],
   ["imap-np", "imap_np"]
 ]);
-function warnLayersUnsupported(format, numLayers, doesLayers) {
-  if (numLayers <= 1 || doesLayers) return;
-  agwarningf(`layers not supported in ${NATIVE_LANGNAME.get(format) ?? format} output`);
+function warnUnsupported(job) {
+  agwarningf(`layers not supported in ${NATIVE_LANGNAME.get(job.format) ?? job.format} output`);
+}
+function numPhysicalLayers(job, info) {
+  return info.layerList !== null ? info.layerList[0] : job.numLayers;
+}
+function firstLayer(job, info, doesLayers) {
+  job.numLayers = info.numLayers;
+  const list = info.layerList;
+  if (list !== null) {
+    if (list[0] > 1 && !doesLayers) {
+      warnUnsupported(job);
+      list[2] = job.numLayers + 1;
+    }
+    job.layerNum = list[1];
+    return { list, pos: 2 };
+  }
+  if (job.numLayers > 1 && !doesLayers) {
+    warnUnsupported(job);
+    job.numLayers = 1;
+  }
+  job.layerNum = 1;
+  return { list: null, pos: 0 };
+}
+function validLayer(job) {
+  return job.layerNum <= job.numLayers;
+}
+function nextLayer(job, cur) {
+  if (cur.list !== null) {
+    job.layerNum = cur.list[cur.pos];
+    cur.pos++;
+  } else {
+    job.layerNum++;
+  }
 }
 
 // src/gvc/device-labels.ts
@@ -28797,7 +28975,7 @@ function renderNode(n, renderer, job, done) {
     job.popObj();
   }
 }
-function setEdgePen(e, job) {
+function setEdgePen(e, job, styles) {
   if (job.obj === null) return;
   const obj = job.obj;
   const flags = parseStyleFlags(e.attrs.get("style"));
@@ -28807,24 +28985,24 @@ function setEdgePen(e, job) {
   );
   obj.pen = resolvePenType(flags);
   obj.penWidth = resolvePenWidth(flags, e.attrs.get("penwidth"));
-  obj.rawStyle = styleTokens(e.attrs.get("style"));
+  obj.rawStyle = [...styles];
   if (e.info.spl !== void 0) gvrenderSetStyle(obj.rawStyle);
 }
 function renderEdge(e, renderer, job) {
   emitEdgeComments(e, renderer, job);
   const edgeStyle = e.attrs.get("style");
+  const styles = styleTokens(edgeStyle);
   if (parseStyleFlags(edgeStyle).invis || styleHasInvisibleAlias(edgeStyle)) return;
   const obj = createObjState(3 /* Edge */);
   obj.emitState = 9 /* EDraw */;
   job.pushObj(obj);
-  setEdgePen(e, job);
+  setEdgePen(e, job, styles);
   try {
     setHtmlAnchorObj(svgEdgeId(e, job), labelTextOf2(e.info.label), job.obj ?? void 0);
     resolveEdgeAnchor(e, svgEdgeId(e, job), obj);
     withColorScheme(e.attrs.get("colorscheme"), () => {
       renderer.beginEdge(e, job);
       reportEdgeColors(e);
-      const styles = styleTokens(e.attrs.get("style"));
       for (let i = edgeStyleResets(e, styles); i > 0; i--) gvrenderSetStyle(styles);
       reportEdgeLabelColors(e);
       renderer.endEdge(e, job);
@@ -28851,6 +29029,22 @@ function renderClusterBox(sg, filled, renderer, job) {
   const rawPts = [{ x: ll.x, y: ll.y }, { x: ll.x, y: ur.y }, { x: ur.x, y: ur.y }, { x: ur.x, y: ll.y }];
   renderer.polygon(rawPts.map((p) => transformPoint(p, job)), filled, job);
 }
+function drawClusterInScheme(sg, renderer, job) {
+  const filled = applyClusterObjState(sg, job);
+  renderer.beginCluster?.(sg, job);
+  if (job.obj !== null) job.obj.id = svgClusterId(sg, job);
+  setHtmlAnchorObj(svgClusterId(sg, job), labelTextOf2(sg.info.label), job.obj ?? void 0);
+  if (job.obj !== null) {
+    resolveObjAnchor(sg, labelTextOf2(sg.info.label), svgClusterId(sg, job), job.obj);
+  }
+  const anchored = beginAnchorIf(renderer, job);
+  if ((clusterPeripheries(sg) !== 0 || filled || isStripedCluster(sg)) && job.obj?.pen !== 0 /* None */) {
+    renderClusterBox(sg, filled, renderer, job);
+  }
+  renderClusterLabel(sg, renderer, job);
+  if (anchored) renderer.endAnchor?.(job);
+  renderer.endCluster?.(sg, job);
+}
 function renderOneCluster(sg, renderer, job) {
   const clustersLast = (job.flags & EMIT_CLUSTERS_LAST) !== 0;
   if (clustersLast) renderClusters(sg, renderer, job);
@@ -28858,20 +29052,7 @@ function renderOneCluster(sg, renderer, job) {
   obj.emitState = 1 /* CDraw */;
   job.pushObj(obj);
   try {
-    const filled = applyClusterObjState(sg, job);
-    renderer.beginCluster?.(sg, job);
-    if (job.obj !== null) job.obj.id = svgClusterId(sg, job);
-    setHtmlAnchorObj(svgClusterId(sg, job), labelTextOf2(sg.info.label), job.obj ?? void 0);
-    if (job.obj !== null) {
-      resolveObjAnchor(sg, labelTextOf2(sg.info.label), svgClusterId(sg, job), job.obj);
-    }
-    const anchored = beginAnchorIf(renderer, job);
-    if ((clusterPeripheries(sg) !== 0 || filled || isStripedCluster(sg)) && job.obj?.pen !== 0 /* None */) {
-      renderClusterBox(sg, filled, renderer, job);
-    }
-    renderClusterLabel(sg, renderer, job);
-    if (anchored) renderer.endAnchor?.(job);
-    renderer.endCluster?.(sg, job);
+    withColorScheme(clusterAttr(sg, "colorscheme"), () => drawClusterInScheme(sg, renderer, job));
   } finally {
     job.popObj();
   }
@@ -28892,16 +29073,15 @@ function renderGraph(g, job, renderer) {
   job.pushObj(obj);
   try {
     const info = parseLayers(g);
-    const layered = renderer.beginLayer !== void 0 && info.numLayers > 1;
-    job.numLayers = layered ? info.numLayers : 1;
+    job.layerNum = 0;
     job.layerIDs = info.layerIDs;
     renderer.beginGraph(g, job);
-    warnLayersUnsupported(job.format, info.numLayers, renderer.beginLayer !== void 0);
-    for (let ln = 1; ln <= job.numLayers; ln++) {
-      job.layerNum = ln;
-      if (layered) renderer.beginLayer(info.layerIDs[ln], job);
+    const cur = firstLayer(job, info, renderer.beginLayer !== void 0);
+    for (; validLayer(job); nextLayer(job, cur)) {
+      const layered = numPhysicalLayers(job, info) > 1;
+      if (layered) renderer.beginLayer?.(info.layerIDs[job.layerNum], job);
       renderPage(g, renderer, job, info);
-      if (layered) renderer.endLayer(job);
+      if (layered) renderer.endLayer?.(job);
     }
     renderer.endGraph(g, job);
   } finally {
@@ -35370,6 +35550,20 @@ function addXLabels(gp) {
   runPlacement(gp);
 }
 
+// src/common/layout-state.ts
+var GVBEGIN = 0;
+var GVSPLINES = 1;
+var layoutState = { state: GVBEGIN };
+registerRenderState(() => {
+  layoutState.state = GVBEGIN;
+});
+function getState() {
+  return layoutState.state;
+}
+function setState(value) {
+  layoutState.state = value;
+}
+
 // src/common/postproc.ts
 var IGNORED_EDGE = 6;
 var Rankdir = 0;
@@ -35461,6 +35655,7 @@ function translateDrawing(g) {
   if (!shift && !Rankdir) return;
   for (const v of g.nodes.values()) {
     mapNode(v);
+    if (getState() !== GVSPLINES) continue;
     for (const e of g.edges) {
       if (e.tail !== v) continue;
       if (e.info.spl === void 0) {
@@ -39450,6 +39645,7 @@ function orthoDispatch(g) {
   } else rc = dispatchOrthoEdges(g, false);
   if (rc !== 0) return rc;
   placePortLabels(g);
+  setState(GVSPLINES);
   g.info.edgeLabelsDone = true;
   return 0;
 }
@@ -39464,6 +39660,7 @@ function finalizeSplines(g, et, normalize) {
   if (normalize) edgeNormalize(g);
   if (et !== EDGETYPE_CURVED) routeDotEdges(g);
   placePortLabels(g);
+  setState(GVSPLINES);
   g.info.edgeLabelsDone = true;
 }
 function dotSplines_(g, normalize) {
@@ -41163,10 +41360,6 @@ function gvPermutation(bound) {
 
 // src/layout/neato/matrix-ops.ts
 var fr = Math.fround;
-function fma2(a, b, c) {
-  const p = a * b;
-  return Number.isFinite(p) && Number.isFinite(c) ? fma(a, b, c) : p + c;
-}
 function orthog1(n, vec) {
   let sum = 0;
   for (let i = 0; i < n; i++) sum += vec[i];
@@ -41195,10 +41388,6 @@ function rightMultWithVectorFF(m, n, vector, result) {
 function vectorsSubtractionF(n, v1, v2, result) {
   for (let i = 0; i < n; i++) result[i] = v1[i] - v2[i];
 }
-function vectorsMultAdditionF(n, v1, alpha, v2) {
-  const a = fr(alpha);
-  for (let i = 0; i < n; i++) v1[i] = v1[i] + fr(a * v2[i]);
-}
 function vectorsInnerProductF(n, v1, v2) {
   let result = 0;
   for (let i = 0; i < n; i++) result += fr(v1[i] * v2[i]);
@@ -41239,11 +41428,11 @@ function innerProduct(n, v1, v2, block) {
   const blocked = block === BLOCK_NONE ? 0 : n - n % block;
   let i = 0;
   for (; i < blocked; i++) result += v1[i] * v2[i];
-  for (; i < n; i++) result = fma2(v1[i], v2[i], result);
+  for (; i < n; i++) result = fma(v1[i], v2[i], result);
   return result;
 }
 function scadd(vec1, end, fac, vec2) {
-  for (let i = 0; i <= end; i++) vec1[i] = fma2(fac, vec2[i], vec1[i]);
+  for (let i = 0; i <= end; i++) vec1[i] = fma(fac, vec2[i], vec1[i]);
 }
 function norm(vec, end, block) {
   return Math.sqrt(innerProduct(end + 1, vec, vec, block));
@@ -41275,7 +41464,7 @@ function rightMultWithVectorF(matrix, n, vector, result, block) {
     let res = 0;
     let j = 0;
     for (; j < blocked; j++) res += row[j] * vector[j];
-    for (; j < n; j++) res = fma2(row[j], vector[j], res);
+    for (; j < n; j++) res = fma(row[j], vector[j], res);
     result[i] = res;
   }
 }
@@ -41283,7 +41472,7 @@ function rightMultWithVector(matrix, n, vector, result) {
   for (let i = 0; i < n; i++) {
     let res = 0;
     const row = matrix[i];
-    for (let j = 0; j < row.nedges; j++) res = fma2(row.ewgts[j], vector[row.edges[j]], res);
+    for (let j = 0; j < row.nedges; j++) res = fma(row.ewgts[j], vector[row.edges[j]], res);
     result[i] = res;
   }
 }
@@ -41401,6 +41590,16 @@ function conjugateGradientF(A3, x, b, n, opts) {
 var TOLERANCE_CG = 1e-3;
 var DFLT_ITERATIONS = 200;
 var OPT_SMART_INIT = 4;
+var OPT_EXP_FLAG = 3;
+var EXP_NAME = "stresswt";
+function checkExp(g) {
+  const exp = lateInt(g.attrs.get(EXP_NAME), 2, 0);
+  if (exp === 0 || exp > 2) {
+    agwarningf(`${EXP_NAME} attribute value must be 1 or 2 - ignoring`);
+    return 2;
+  }
+  return exp;
+}
 function mdsModel(graph, nG) {
   if (graph[0].ewgts.length === 0) return null;
   const Dij = computeWeightedApspPacked(graph, nG);
@@ -41500,19 +41699,40 @@ function dijkstraSgd(graph, source, terms) {
 
 // src/layout/neato/edge-len.ts
 var DEFAULT_EDGE_LEN = 1;
+var DOUBLE_PREFIX = /^\s*([+-]?)(0x(?:[\da-f]+\.?[\da-f]*|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?|inf(?:inity)?|nan(?:\([\w]*\))?)/i;
+function scanDouble(s) {
+  const m = DOUBLE_PREFIX.exec(s);
+  if (m === null) return null;
+  const body = m[2].toLowerCase();
+  const sign2 = m[1] === "-" ? -1 : 1;
+  if (body.startsWith("nan")) return Number.NaN;
+  if (body.startsWith("inf")) return sign2 * Infinity;
+  if (!body.startsWith("0x")) return sign2 * parseFloat(body);
+  const [mant, exp] = body.slice(2).split("p");
+  const [ip = "", fp = ""] = mant.split(".");
+  const digits = parseInt(ip + fp || "0", 16);
+  return sign2 * digits * 2 ** (Number(exp ?? 0) - 4 * fp.length);
+}
 function lenattr(ep, g) {
   const s = ep.attrs.get("len");
   if (s === void 0 || s === "") return DEFAULT_EDGE_LEN;
-  const val2 = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(s);
-  const len = val2 === null ? Number.NaN : parseFloat(val2[0]);
-  if (Number.isNaN(len) || len < 0 || len === 0) {
-    agwarningf(`bad edge len "${s}" in ${g.name} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
+  const len = scanDouble(s);
+  if (len === null || len < 0 || len === 0) {
+    agwarningf(`bad edge len "${s}" in ${agNameOf(g)} - setting to ${DEFAULT_EDGE_LEN.toFixed(2)}`);
     return DEFAULT_EDGE_LEN;
   }
   return len;
 }
 function setEdgeLen(g) {
-  for (const ep of g.edges) ep.info.dist = lenattr(ep, g);
+  const out = buildOutEdgeIndex(g);
+  let total = 0;
+  for (const np of g.nodes.values()) {
+    for (const ep of out.get(np) ?? []) {
+      ep.info.dist = lenattr(ep, g);
+      total += ep.info.dist;
+    }
+  }
+  return total;
 }
 
 // src/util/mt19937.ts
@@ -41670,7 +41890,7 @@ function neatoMode(g) {
   if (str === void 0 || str === "") return MODE_MAJOR;
   const mode = modeByName().get(str);
   if (mode !== void 0) return mode;
-  agwarningf(`Illegal value ${str} for attribute "mode" in graph ${g.root.name} - ignored`);
+  agwarningf(`Illegal value ${str} for attribute "mode" in graph ${agNameOf(g.root)} - ignored`);
   return MODE_MAJOR;
 }
 function checkMode(g, mode) {
@@ -41715,7 +41935,7 @@ function warnCircuitDisconnected(g) {
   circuitWarned.add(g.root);
   agerrLineOn(
     "warn",
-    `graph ${g.root.name} is disconnected. Hence, the circuit model
+    `graph ${agNameOf(g.root)} is disconnected. Hence, the circuit model
 is undefined. Reverting to the shortest path model.
 Alternatively, consider running neato using -Gpack=true or decomposing
 the graph into connected components.`
@@ -42326,7 +42546,7 @@ function moveNode(st, m) {
 function solveModel(g, st) {
   for (let m = chooseNode(st); m >= 0; m = chooseNode(st)) moveNode(st, m);
   if (st.move === st.maxIter) {
-    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${g.name}`);
+    agwarningf(`Max. iterations (${st.maxIter}) reached on graph ${agNameOf(g)}`);
   }
 }
 function mdsEdges(g, nodes, lens) {
@@ -42409,7 +42629,7 @@ function addNeighbours(g, np, entry, o) {
     if (ep.head === ep.tail) continue;
     const vp = ep.tail === np ? ep.head : ep.tail;
     const vid = vp.info.id;
-    const dist5 = o.haveLen ? lateDouble(ep.attrs.get("len"), 1, 0) : 1;
+    const dist5 = o.haveLen ? ep.info.dist ?? 0 : 1;
     const idx = seen2.get(vid);
     if (idx !== void 0) {
       if (o.haveLen) entry.ewgts[idx] = Math.max(entry.ewgts[idx], dist5);
@@ -42951,7 +43171,7 @@ function matMultVecOrthog(mat, dim, vec, result, orthog) {
     let sum = 0;
     let j = 0;
     for (; j < blocked; j++) sum += row[j] * vec[j];
-    for (; j < dim; j++) sum = fma2(row[j], vec[j], sum);
+    for (; j < dim; j++) sum = fma(row[j], vec[j], sum);
     result[i] = sum;
   }
   const alpha = -innerProduct(dim, result, orthog, BLOCK_MAT_MULT_ORTHOG);
@@ -43050,8 +43270,8 @@ function computeAvgs(Dij, n) {
       sumRow += row[j] * row[j];
     }
     for (; j < n; j++) {
-      sum = fma2(row[j], row[j], sum);
-      sumRow = fma2(row[j], row[j], sumRow);
+      sum = fma(row[j], row[j], sum);
+      sumRow = fma(row[j], row[j], sumRow);
     }
     rowAvg[i] = fr4(fr4(sumRow) / n);
   }
@@ -43064,7 +43284,7 @@ function computeBij(Dij, n) {
   for (let i = 0; i < n; i++) {
     for (let j = 0; j <= i; j++) {
       const fD = fr4(Dij[i][j]);
-      const t = fr4(fma2(-fD, fD, rowAvg[i]));
+      const t = fr4(fma(-fD, fD, rowAvg[i]));
       Bij[i][j] = fr4(fr4(t + rowAvg[j]) - allAvg);
       Bij[j][i] = Bij[i][j];
     }
@@ -43096,8 +43316,8 @@ function scaleGivenCoords(Dij, n, x) {
         sum1 += t1 * f;
         sum2 += t2 * f;
       } else {
-        sum1 = fma2(t1, f, sum1);
-        sum2 = fma2(t2, f, sum2);
+        sum1 = fma(t1, f, sum1);
+        sum2 = fma(t2, f, sum2);
       }
     }
   }
@@ -43127,7 +43347,7 @@ function computeResidualDistances(Dij, n, x) {
     for (let j = 0; j < i; j++) {
       const t = posI - x[j];
       const d = Dij[i][j];
-      const diff = fma2(d, d, -(t * t));
+      const diff = fma(d, d, -(t * t));
       const v = diff > 0 ? Math.sqrt(diff) : 0;
       Dij[i][j] = v;
       Dij[j][i] = v;
@@ -43184,8 +43404,6 @@ function imdsGivenDim(graph, n, givenCoords, newCoords, conjTol) {
 
 // src/layout/neato/stress-kernel.ts
 var fr5 = Math.fround;
-var TOLERANCE_CG2 = 1e-3;
-var OPT_EXP_FLAG = 2;
 function computeApspPacked2(graph, n) {
   const Dij = new Float32Array(n * (n + 1) / 2);
   const Di = new Int32Array(n);
@@ -43229,51 +43447,16 @@ function initLayout(n, dim, coords, nodes) {
   for (let d = 0; d < dim; d++) orthog1(n, coords[d]);
   return pinned;
 }
-function cgStep(st, last) {
-  const { n } = st;
-  orthog1f(n, st.p);
-  orthog1f(n, st.x);
-  orthog1f(n, st.r);
-  rightMultWithVectorFF(st.A, n, st.p, st.Ap);
-  orthog1f(n, st.Ap);
-  const pAp = vectorsInnerProductF(n, st.p, st.Ap);
-  if (pAp === 0) return true;
-  const alpha = st.rR / pAp;
-  vectorsMultAdditionF(n, st.x, alpha, st.p);
-  if (!last) {
-    vectorsMultAdditionF(n, st.r, -alpha, st.Ap);
-    const rRNew = vectorsInnerProductF(n, st.r, st.r);
-    if (st.rR === 0) return false;
-    const betaF = fr5(rRNew / st.rR);
-    st.rR = rRNew;
-    for (let j = 0; j < n; j++) st.p[j] = fr5(betaF * st.p[j]) + st.r[j];
-  }
-  return true;
-}
-function conjugateGradientMkernel2(A3, x, b, n, tol, maxIterations) {
-  const st = {
-    A: A3,
-    x,
-    b,
-    n,
-    r: new Float32Array(n),
-    p: new Float32Array(n),
-    Ap: new Float32Array(n),
-    rR: 0
-  };
-  orthog1f(n, x);
-  orthog1f(n, b);
-  const Ax = new Float32Array(n);
-  rightMultWithVectorFF(A3, n, x, Ax);
-  orthog1f(n, Ax);
-  vectorsSubtractionF(n, b, Ax, st.r);
-  copyVectorF(n, st.r, st.p);
-  st.rR = vectorsInnerProductF(n, st.r, st.r);
-  for (let i = 0; i < maxIterations && maxAbsF(n, st.r) > tol; i++) {
-    if (!cgStep(st, i >= maxIterations - 1)) return -1;
-  }
-  return 0;
-}
+var FUSED_OPS = {
+  squareAdd: (tmp, acc) => fmaf(tmp, tmp, acc),
+  rightMult: rightMultWithVectorFFFused,
+  cg: conjugateGradientMkernelFused
+};
+var COLA_OPS = {
+  squareAdd: (tmp, acc) => acc + fr5(tmp * tmp),
+  rightMult: rightMultWithVectorFF,
+  cg: conjugateGradientMkernelFused
+};
 function buildLap2(lap2, n, exp) {
   const lapLength = n * (n + 1) / 2;
   if (exp === 2) squareVec(lapLength, lap2);
@@ -43296,7 +43479,7 @@ function buildLap2(lap2, n, exp) {
   }
 }
 function buildLap1(lap1, lap2, coords, shape) {
-  const { n, dim, exp } = shape;
+  const { n, dim, exp, ops } = shape;
   const lapLength = n * (n + 1) / 2;
   const degrees = new Float64Array(n);
   const distAccumulator = new Float32Array(n);
@@ -43309,7 +43492,7 @@ function buildLap1(lap1, lap2, coords, shape) {
       const ck = coords[k];
       for (let x = 0; x < len; x++) {
         const tmp = fr5(ck[i] + fr5(-1 * ck[i + 1 + x]));
-        distAccumulator[x] = distAccumulator[x] + fr5(tmp * tmp);
+        distAccumulator[x] = ops.squareAdd(tmp, distAccumulator[x]);
       }
     }
     invertSqrtVec(len, distAccumulator);
@@ -43342,24 +43525,25 @@ function buildLap1(lap1, lap2, coords, shape) {
 function computeStress(st) {
   let stress = 0;
   for (let k = 0; k < st.dim; k++) {
-    rightMultWithVectorFF(st.lap1, st.n, st.coords[k], st.b[k]);
+    st.ops.rightMult(st.lap1, st.n, st.coords[k], st.b[k]);
     stress += vectorsInnerProductF(st.n, st.coords[k], st.b[k]);
   }
   stress *= 2;
   stress += st.constantTerm;
   for (let k = 0; k < st.dim; k++) {
-    rightMultWithVectorFF(st.lap2, st.n, st.coords[k], st.tmpCoords);
+    st.ops.rightMult(st.lap2, st.n, st.coords[k], st.tmpCoords);
     stress -= vectorsInnerProductF(st.n, st.coords[k], st.tmpCoords);
   }
   return stress;
 }
 function solveAxis(st, k, havePinned, nodes) {
+  const cg = { tol: TOLERANCE_CG, maxIterations: st.n };
   if (!havePinned) {
-    return conjugateGradientMkernel2(st.lap2, st.coords[k], st.b[k], st.n, TOLERANCE_CG2, st.n);
+    return st.ops.cg(st.lap2, st.coords[k], st.b[k], st.n, cg);
   }
   copyVectorF(st.n, st.coords[k], st.tmpCoords);
-  const rc = conjugateGradientMkernel2(st.lap2, st.tmpCoords, st.b[k], st.n, TOLERANCE_CG2, st.n);
-  if (rc < 0) return rc;
+  const rc = st.ops.cg(st.lap2, st.tmpCoords, st.b[k], st.n, cg);
+  if (rc !== 0) return rc;
   for (let i = 0; i < st.n; i++) {
     if (!isFixed(nodes[i])) st.coords[k][i] = st.tmpCoords[i];
   }
@@ -43390,20 +43574,21 @@ function stressMajorizationKDMkernel(Dij, n, dCoords, nodes, o) {
     coords,
     b: Array.from({ length: dim }, () => new Float32Array(n)),
     tmpCoords: new Float32Array(n),
-    constantTerm
+    constantTerm,
+    ops: o.cola === true ? COLA_OPS : FUSED_OPS
   };
   let oldStress = Number.MAX_VALUE;
   let converged = false;
   let iterations = 0;
   for (; iterations < maxi && !converged; iterations++) {
-    buildLap1(st.lap1, lap2, coords, { n, dim, exp });
+    buildLap1(st.lap1, lap2, coords, { n, dim, exp, ops: st.ops });
     const newStress = computeStress(st);
     if (typeof process !== "undefined" && process.env["STRESS_DEBUG"] && iterations % 5 === 0) console.error(newStress.toFixed(3));
     const change = Math.abs(oldStress - newStress);
     converged = change / oldStress < o.epsilon || newStress < o.epsilon;
     oldStress = newStress;
     for (let k = 0; k < dim; k++) {
-      if (solveAxis(st, k, havePinned, nodes) < 0) return -1;
+      if (solveAxis(st, k, havePinned, nodes) !== 0) return -1;
     }
   }
   for (let i = 0; i < dim; i++) {
@@ -43491,7 +43676,7 @@ function distanceKD(coords, dim, i, j) {
   let sum = 0;
   for (let k = 0; k < dim; k++) {
     const d = coords[k][i] - coords[k][j];
-    sum = fma2(d, d, sum);
+    sum = fma(d, d, sum);
   }
   return Math.sqrt(sum);
 }
@@ -43668,10 +43853,10 @@ function stressMajorizationWithHierarchy(graph, n, dCoords, nodes, o) {
 }
 
 // src/common/utils-inputscale.ts
-var POINTS_PER_INCH3 = 72;
+var POINTS_PER_INCH4 = 72;
 function getInputscale(g) {
   const d = lateDouble(g.root.attrs.get("inputscale"), -1, 0);
-  return d === 0 ? POINTS_PER_INCH3 : d;
+  return d === 0 ? POINTS_PER_INCH4 : d;
 }
 function inputscaleDivisor(g) {
   const sc = getInputscale(g);
@@ -43679,7 +43864,7 @@ function inputscaleDivisor(g) {
 }
 
 // src/layout/neato/set-aspect.ts
-var POINTS_PER_INCH4 = 72;
+var POINTS_PER_INCH5 = 72;
 function neatoRatioKind(g) {
   const p = g.attrs.get("ratio");
   if (p === void 0) return null;
@@ -43727,8 +43912,8 @@ function neatoTranslate(g) {
   const bb = g.info.bb;
   if (!bb) return;
   const ll = bb.ll;
-  const ox = ll.x / POINTS_PER_INCH4;
-  const oy = ll.y / POINTS_PER_INCH4;
+  const ox = ll.x / POINTS_PER_INCH5;
+  const oy = ll.y / POINTS_PER_INCH5;
   for (const n of g.nodes.values()) {
     if (!n.info.pos) n.info.pos = [0, 0];
     n.info.pos[0] = (n.info.pos[0] ?? 0) - ox;
@@ -43814,7 +43999,7 @@ var MODEL_CIRCUIT = 1;
 var MODEL_SUBSET = 2;
 var MODEL_MDS2 = 3;
 var DFLT_DIM = 2;
-var POINTS_PER_INCH5 = 72;
+var POINTS_PER_INCH6 = 72;
 function neatoInitNode(n, dim = DFLT_DIM) {
   if (!n.info.pos || n.info.pos.length < dim) {
     const pos = [];
@@ -43875,15 +44060,17 @@ function solveStress(c, vtx, dCoords, nodeList) {
     dim: DFLT_DIM,
     opts,
     maxi,
-    epsilon
+    epsilon,
+    cola: mode === MODE_IPSEP
   });
 }
 function runMajorization(g, mode, model) {
   const nodeList = assignNodeIds2(g);
+  setEdgeLen(g);
   const n = nodeList.length;
   const haveLen = graphHasLen(g);
   const init = checkStart(g, n, mode === MODE_HIER ? INIT_SELF : INIT_RANDOM);
-  const opts = init === INIT_SELF ? OPT_EXP_FLAG | OPT_SMART_INIT : OPT_EXP_FLAG;
+  const opts = checkExp(g) | (init === INIT_SELF ? OPT_SMART_INIT : 0);
   const haveDir = mode === MODE_HIER || mode === MODE_IPSEP;
   const vtx = makeGraphDataC(g, nodeList, haveLen, haveDir, mode);
   const dCoords = [new Float64Array(n), new Float64Array(n)];
@@ -43913,12 +44100,14 @@ function neatoSetAspect(g) {
     const pos = n.info.pos;
     if (!pos) continue;
     n.info.coord = {
-      x: (pos[0] ?? 0) * POINTS_PER_INCH5,
-      y: (pos[1] ?? 0) * POINTS_PER_INCH5
+      x: (pos[0] ?? 0) * POINTS_PER_INCH6,
+      y: (pos[1] ?? 0) * POINTS_PER_INCH6
     };
   }
 }
 function neatoCleanup(g) {
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   for (const [, n] of g.nodes) {
     n.info.pos = void 0;
     n.info.pinned = void 0;
@@ -46155,9 +46344,11 @@ function splineEdges(g) {
   coalesceEdges(g);
   if (edgetype === EDGETYPE_LINE) {
     RoutingHelper.straight(g, edgetype);
+    setState(GVSPLINES);
     return;
   }
   splineEdgesImpl(g, esepFactor(g), edgetype);
+  setState(GVSPLINES);
 }
 function computeBBFromPos(g) {
   const bb = {
@@ -48568,6 +48759,8 @@ function getPos(g, dim) {
   return pos;
 }
 function sfdpCleanup(g) {
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   for (const n of g.nodes.values()) {
     n.info.pos = void 0;
     n.info.id = void 0;
@@ -49476,7 +49669,7 @@ var AM_PORTHOYX = 12;
 var SCALE = 10;
 var SCALE2 = SCALE / 2;
 var INT_MAX3 = 2147483647;
-var POINTS_PER_INCH6 = 72;
+var POINTS_PER_INCH7 = 72;
 function cmpitem(a, b) {
   if (a < b) return -1;
   if (a > b) return 1;
@@ -49704,18 +49897,18 @@ function overlaps(p) {
   return false;
 }
 function initItem(n, margin) {
-  const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH6);
-  const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH6);
+  const x = cround(SCALE * (n.info.pos?.[0] ?? 0) * POINTS_PER_INCH7);
+  const y = cround(SCALE * (n.info.pos?.[1] ?? 0) * POINTS_PER_INCH7);
   const width2 = n.info.width ?? 0;
   const height2 = n.info.height ?? 0;
   let w2;
   let h2;
   if (margin.doAdd) {
-    w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH6) + margin.x));
-    h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH6) + margin.y));
+    w2 = d2i(SCALE * (cround(width2 / 2 * POINTS_PER_INCH7) + margin.x));
+    h2 = d2i(SCALE * (cround(height2 / 2 * POINTS_PER_INCH7) + margin.y));
   } else {
-    w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH6);
-    h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH6);
+    w2 = cround(margin.x * SCALE2 * width2 * POINTS_PER_INCH7);
+    h2 = cround(margin.y * SCALE2 * height2 * POINTS_PER_INCH7);
   }
   return {
     val: 0,
@@ -49750,8 +49943,8 @@ function cAdjust(g, mode) {
   if (!overlaps(nlist)) return 0;
   runPlan(g, nlist, PLANS.get(mode) ?? PLANS.get(AM_PORTHO));
   for (const p of nlist) {
-    const x = p.pos.x / POINTS_PER_INCH6 / SCALE;
-    const y = p.pos.y / POINTS_PER_INCH6 / SCALE;
+    const x = p.pos.x / POINTS_PER_INCH7 / SCALE;
+    const y = p.pos.y / POINTS_PER_INCH7 / SCALE;
     if (p.np.info.pos) {
       p.np.info.pos[0] = x;
       p.np.info.pos[1] = y;
@@ -49766,10 +49959,10 @@ function cAdjust(g, mode) {
 var POLY_BOX = 1;
 var POLY_CIRCLE = 2;
 var DFLT_SAMPLE2 = 20;
-var POINTS_PER_INCH7 = 72;
+var POINTS_PER_INCH8 = 72;
 var MIN_SAMPLES = 3;
 function ps2inch2(a) {
-  return a / POINTS_PER_INCH7;
+  return a / POINTS_PER_INCH8;
 }
 function isBoxKind(p) {
   return (p.kind & POLY_BOX) !== 0;
@@ -50062,7 +50255,7 @@ function polyOverlap(p, pp, q, qp) {
 // src/layout/neato/adjust-info.ts
 var DEFAULT_VORO_MARGIN = 0.05;
 var INCR = 0.05;
-var POINTS_PER_INCH8 = 72;
+var POINTS_PER_INCH9 = 72;
 function newInfoState() {
   return {
     nodeInfo: [],
@@ -50117,8 +50310,8 @@ function chkBoundBox(st, graph) {
 function makeInfo(st, graph) {
   const pmargin = { ...sepFactor(graph) };
   if (pmargin.doAdd) {
-    pmargin.x /= POINTS_PER_INCH8;
-    pmargin.y /= POINTS_PER_INCH8;
+    pmargin.x /= POINTS_PER_INCH9;
+    pmargin.y /= POINTS_PER_INCH9;
   }
   const polyf = pmargin.doAdd ? makeAddPoly : makePoly;
   const info = [];
@@ -51184,7 +51377,7 @@ function genYConstraints(rects, vs) {
 }
 
 // src/layout/neato/vpsc-adjust.ts
-var POINTS_PER_INCH9 = 72;
+var POINTS_PER_INCH10 = 72;
 var X_PASS_SCALE = Math.fround(1.0001);
 function buildRects(c, size, gap, scale) {
   return size.map((s, i) => {
@@ -51209,8 +51402,8 @@ function solveAxis2(c, size, gap, axis) {
 function vpscAdjust(g) {
   const margin = sepFactor(g);
   const gap = {
-    x: 2 * (margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH9,
-    y: 2 * (margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH9
+    x: 2 * (margin.doAdd ? margin.x : DFLT_MARGIN) / POINTS_PER_INCH10,
+    y: 2 * (margin.doAdd ? margin.y : DFLT_MARGIN) / POINTS_PER_INCH10
   };
   const nodes = Array.from(g.nodes.values());
   const c = [new Float32Array(nodes.length), new Float32Array(nodes.length)];
@@ -51389,7 +51582,7 @@ function graphAdjustMode(g) {
 }
 
 // src/layout/twopi/init.ts
-var POINTS_PER_INCH10 = 72;
+var POINTS_PER_INCH11 = 72;
 function makeRdata(INF) {
   return {
     kind: "twopi",
@@ -51441,19 +51634,24 @@ function finaliseCoords(g) {
     const pos = n.info.pos;
     if (!pos) continue;
     n.info.coord = {
-      x: (pos[0] ?? 0) * POINTS_PER_INCH10,
-      y: (pos[1] ?? 0) * POINTS_PER_INCH10
+      x: (pos[0] ?? 0) * POINTS_PER_INCH11,
+      y: (pos[1] ?? 0) * POINTS_PER_INCH11
     };
   }
 }
 function adjustNodes(g) {
   adjustNodesFull(g);
 }
-function twopiCleanup(g) {
+function twopiFreeAlg(g) {
   const first = g.nodes.values().next().value;
   if (first !== void 0 && first.info.alg?.kind === "twopi") {
     first.info.alg = void 0;
   }
+}
+function twopiCleanup(g) {
+  if (g.nodes.size === 0) return;
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   g.info.neato_nlist = void 0;
 }
 
@@ -51722,7 +51920,7 @@ function layoutSingle(g, comps, globalRoot, setRoot) {
   if (setRoot && globalRoot === null && center !== null) {
     g.attrs.set("root", center.name);
   }
-  twopiCleanup(g);
+  twopiFreeAlg(g);
   splineEdgesShifted(g);
   finaliseCoords(g);
 }
@@ -51731,7 +51929,7 @@ function layoutMulti(g, comps, globalRoot, pinfo) {
     layoutComponent(g, sg, globalRoot);
     finaliseCoords(sg);
   }
-  twopiCleanup(g);
+  twopiFreeAlg(g);
   packSubgraphs(comps.length, comps, g, pinfo);
   splineEdgesShifted(g);
   finaliseCoords(g);
@@ -52135,7 +52333,18 @@ function fdpInitNodeEdge(g) {
   }
   initialPositions3(g);
 }
+function fdpCleanupSubgs(g) {
+  const nClust = g.info.n_cluster ?? 0;
+  for (let i = 1; i <= nClust; i++) {
+    const subg = g.info.clust[i - 1];
+    subg.info.label = void 0;
+    fdpCleanupSubgs(subg);
+  }
+}
 function fdpCleanup(g) {
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
+  fdpCleanupSubgs(g);
   for (const n of g.nodes.values()) {
     n.info.alg = void 0;
     n.info.pos = void 0;
@@ -53079,7 +53288,7 @@ function expandCluster2(n, cg) {
 }
 
 // src/layout/fdp/layout.ts
-var POINTS_PER_INCH11 = 72;
+var POINTS_PER_INCH12 = 72;
 var DEFAULT_NODEWIDTH_PTS = 54;
 var DEFAULT_NODEHEIGHT_PTS = 36;
 function initInfo(g) {
@@ -53174,7 +53383,7 @@ function shiftComponents(cc, pts, pt) {
     } else {
       p = pt;
     }
-    const del = { x: p.x / POINTS_PER_INCH11, y: p.y / POINTS_PER_INCH11 };
+    const del = { x: p.x / POINTS_PER_INCH12, y: p.y / POINTS_PER_INCH12 };
     for (const n of cc[i].nodes.values()) {
       n.info.pos[0] += del.x;
       n.info.pos[1] += del.y;
@@ -53190,8 +53399,8 @@ function finalCC(g, cc, pts, rg, infop) {
   const pt = applyMarginAndBorder(rg, bb, margin);
   if (cc.length > 0) shiftComponents(cc, pts, pt);
   gdata(g).bb = {
-    ll: { x: bb.ll.x / POINTS_PER_INCH11, y: bb.ll.y / POINTS_PER_INCH11 },
-    ur: { x: bb.ur.x / POINTS_PER_INCH11, y: bb.ur.y / POINTS_PER_INCH11 }
+    ll: { x: bb.ll.x / POINTS_PER_INCH12, y: bb.ll.y / POINTS_PER_INCH12 },
+    ur: { x: bb.ur.x / POINTS_PER_INCH12, y: bb.ur.y / POINTS_PER_INCH12 }
   };
 }
 function applyMarginAndBorder(rg, bb, margin) {
@@ -53237,8 +53446,8 @@ function translateOwnNodes(g, bb) {
 function setBB(g) {
   const bb = gdata(g).bb;
   g.info.bb = {
-    ll: { x: POINTS_PER_INCH11 * bb.ll.x, y: POINTS_PER_INCH11 * bb.ll.y },
-    ur: { x: POINTS_PER_INCH11 * bb.ur.x, y: POINTS_PER_INCH11 * bb.ur.y }
+    ll: { x: POINTS_PER_INCH12 * bb.ll.x, y: POINTS_PER_INCH12 * bb.ll.y },
+    ur: { x: POINTS_PER_INCH12 * bb.ur.x, y: POINTS_PER_INCH12 * bb.ur.y }
   };
   const nClusters = g.info.n_cluster ?? 0;
   for (let i = 0; i < nClusters; i++) {
@@ -53253,8 +53462,8 @@ function setClustNodes(root) {
     const bb = gdata(p).bb;
     const w = bb.ur.x - bb.ll.x;
     const h = bb.ur.y - bb.ll.y;
-    const w2 = POINTS_PER_INCH11 * (w / 2);
-    const h2 = POINTS_PER_INCH11 * (h / 2);
+    const w2 = POINTS_PER_INCH12 * (w / 2);
+    const h2 = POINTS_PER_INCH12 * (h / 2);
     n.info.pos[0] = w / 2;
     n.info.pos[1] = h / 2;
     n.info.width = w;
@@ -53263,7 +53472,7 @@ function setClustNodes(root) {
     n.info.outline_width = w + penwidth;
     n.info.outline_height = h + penwidth;
     n.info.lw = n.info.rw = w2;
-    n.info.ht = POINTS_PER_INCH11 * h;
+    n.info.ht = POINTS_PER_INCH12 * h;
     const poly = n.info.shape_info;
     if (poly && poly.vertices) {
       poly.vertices[0] = { x: w2, y: h2 };
@@ -53276,8 +53485,8 @@ function setClustNodes(root) {
 function syncCoordFromPos(cg) {
   for (const n of cg.nodes.values()) {
     n.info.coord = {
-      x: POINTS_PER_INCH11 * n.info.pos[0],
-      y: POINTS_PER_INCH11 * n.info.pos[1]
+      x: POINTS_PER_INCH12 * n.info.pos[0],
+      y: POINTS_PER_INCH12 * n.info.pos[1]
     };
   }
 }
@@ -53289,8 +53498,8 @@ function expandComponentClusters(cg, infop, counter) {
       if (r !== 0) return r;
       n.info.width = gdata(sg).bb.ur.x;
       n.info.height = gdata(sg).bb.ur.y;
-      const ptx = POINTS_PER_INCH11 * gdata(sg).bb.ur.x;
-      const pty = POINTS_PER_INCH11 * gdata(sg).bb.ur.y;
+      const ptx = POINTS_PER_INCH12 * gdata(sg).bb.ur.x;
+      const pty = POINTS_PER_INCH12 * gdata(sg).bb.ur.y;
       n.info.rw = n.info.lw = ptx / 2;
       n.info.ht = pty;
     } else if (isPort(n)) {
@@ -54940,6 +55149,9 @@ function circoLayoutFull(g) {
   gvPostprocess(g);
 }
 function circoCleanup(g) {
+  if (g.nodes.size === 0) return;
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   g.info.alg = void 0;
   g.info.neato_nlist = void 0;
 }
@@ -55227,11 +55439,17 @@ function osageLayout(g) {
 }
 function cleanupGraphs(g) {
   const nClust = g.info.n_cluster ?? 0;
-  for (let i = 1; i <= nClust; i++) cleanupGraphs(g.info.clust[i - 1]);
+  for (let i = 1; i <= nClust; i++) {
+    const subg = g.info.clust[i - 1];
+    subg.info.label = void 0;
+    cleanupGraphs(subg);
+  }
   g.info.clust = void 0;
   g.info.n_cluster = void 0;
 }
 function osageCleanup(g) {
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   for (const n of g.nodes.values()) {
     if (n.info.alg?.kind === "osage") n.info.alg = void 0;
   }
@@ -55582,6 +55800,9 @@ function patchworkEngineLayout(g) {
   gvPostprocess(g);
 }
 function patchworkEngineCleanup(g) {
+  if (g.nodes.size === 0) return;
+  for (const e of g.edges) gvCleanupEdgeLabels(e);
+  for (const n of g.nodes.values()) gvCleanupNodeLabels(n);
   g.info.clust = void 0;
   g.info.n_cluster = void 0;
   for (const n of g.nodes.values()) {
@@ -56281,7 +56502,7 @@ var PlainExtRenderer = class {
   }
 };
 function mapGraphName(g) {
-  return g.anonymous ? "%1" : g.name;
+  return agNameOf(g);
 }
 function graphAttr2(g, key) {
   for (let s = g; s !== null; s = s.parent) {
@@ -58620,8 +58841,8 @@ function latin1Reencode(s) {
   for (const b of bytes) out += String.fromCharCode(b);
   return out;
 }
-function buildJson(g, doXDot) {
-  const draws = doXDot ? collectDrawLookup(g) : void 0;
+function buildJson(g, doXDot, preDraws) {
+  const draws = doXDot ? preDraws ?? collectDrawLookup(g) : void 0;
   const ctx = assignIds(g, doXDot, draws);
   const root = buildGraphObject(g, true, ctx);
   return JSON.stringify(root, null, 2) + "\n";
@@ -58658,10 +58879,15 @@ var JsonRenderer = class {
   type = "json";
   /** @see plugin/core/gvplugin_core.c registration table */
   quality = 0;
-  beginGraph(_g, _job) {
+  draws;
+  // set by beginGraph, cleared by endGraph
+  /** @see plugin/core/gvrender_core_json.c:json_begin_graph */
+  beginGraph(g, _job) {
+    this.draws = collectDrawLookup(g);
   }
   endGraph(g, job) {
-    job.write(buildJson(g, true));
+    job.write(buildJson(g, true, this.draws));
+    this.draws = void 0;
   }
   beginNode(_n, _job) {
   }
@@ -59409,16 +59635,16 @@ function isDoomedNode(node) {
   return BANNED_ELEMENTS.has(localNameOf(node)) || isHostileAnimation(node);
 }
 function scrubSvgDocument(doc) {
-  const pending = [doc];
-  while (pending.length > 0) {
-    const parent2 = pending.pop();
+  const pending2 = [doc];
+  while (pending2.length > 0) {
+    const parent2 = pending2.pop();
     const children = Array.from(parent2.childNodes);
     for (const child of children) {
       if (isDoomedNode(child)) {
         parent2.removeChild(child);
       } else if (child.nodeType === ELEMENT_NODE) {
         scrubAttributes(child);
-        pending.push(child);
+        pending2.push(child);
       }
     }
   }