@diagrammo/dgmo 0.95.0 → 0.97.0

package/dist/{chunk-USE6HIOZ.js → chunk-MJ725XHD.js}

@@ -1,6 +1,12 @@
 import {
   renderDataChartD3
-} from "./chunk-YQMIKX54.js";
+} from "./chunk-XCYGOCMS.js";
+import {
+  readViewBox
+} from "./chunk-6K2W3FH7.js";
+import {
+  computeQuadrantPointLabels
+} from "./chunk-YSDSFXQD.js";
 import {
   REGISTRY_BY_ID,
   getRenderCategory,
@@ -12,7 +18,7 @@ import {
   parseVenn,
   parseVisualization,
   parseWordcloud
-} from "./chunk-P5XA627W.js";
+} from "./chunk-2FMOLWX4.js";
 import {
   parseChart,
   parseFunctionChart,
@@ -20,61 +26,64 @@ import {
   parseHeatmap,
   parseSankey,
   parseScatter
-} from "./chunk-H6BT45SN.js";
+} from "./chunk-WPYJAHRP.js";
+import {
+  MAP_DX
+} from "./chunk-EOYPX6SF.js";
+import {
+  parseTechRadar
+} from "./chunk-DKMZ4VMV.js";
 import {
   parsePyramid
-} from "./chunk-3PP746YM.js";
+} from "./chunk-CGP7RGLJ.js";
 import {
   parseRing
-} from "./chunk-NM5V5EKY.js";
+} from "./chunk-QLIZ7SB7.js";
 import {
   parseTreemap
-} from "./chunk-3KVUFHUJ.js";
-import {
-  MAP_DX
-} from "./chunk-EOYPX6SF.js";
+} from "./chunk-NBISN6FH.js";
 import {
-  computeQuadrantPointLabels
-} from "./chunk-KMU65FYM.js";
+  parseSwot
+} from "./chunk-KNKZGRRB.js";
 import {
   parseVersionControl
-} from "./chunk-2ZW4NBYX.js";
+} from "./chunk-R4SXMBGF.js";
 import {
   parseMap
-} from "./chunk-AULZD45V.js";
-import {
-  parseSketch
-} from "./chunk-WZBZXZ6T.js";
+} from "./chunk-IUFTAFGN.js";
 import {
   parseWhiteboard
-} from "./chunk-U6VS3T2M.js";
+} from "./chunk-AULFF7L2.js";
 import {
   parseSwimlane
-} from "./chunk-J7Q4AB23.js";
+} from "./chunk-PZ5LAAO3.js";
 import {
   parseMindmap
-} from "./chunk-XIUGSUE4.js";
-import {
-  parseTechRadar
-} from "./chunk-EBVVMUAA.js";
+} from "./chunk-KTGJQJB3.js";
 import {
   parseKanban
-} from "./chunk-LKZCUFOW.js";
+} from "./chunk-B7ZH5EQ2.js";
 import {
   parseInfra
-} from "./chunk-UXNA2H2V.js";
+} from "./chunk-3C4OXVZJ.js";
 import {
   parseJourneyMap
-} from "./chunk-PGSGJLUR.js";
+} from "./chunk-TMB4YY3J.js";
+import {
+  parseGantt
+} from "./chunk-VQWLASDC.js";
 import {
   parseGoal
-} from "./chunk-7PJBJ2DU.js";
+} from "./chunk-ZMVMGZAJ.js";
+import {
+  MIN_CANVAS_WIDTH
+} from "./chunk-K7RRXZHS.js";
 import {
   parseEventLine
-} from "./chunk-3GUEYQGL.js";
+} from "./chunk-L3K5O3Z5.js";
 import {
   renderTimeline
-} from "./chunk-TASRGDYP.js";
+} from "./chunk-EEIGHOJR.js";
 import {
   EXPORT_HEIGHT,
   EXPORT_WIDTH,
@@ -86,93 +95,94 @@ import {
   renderChartTitle,
   resolveExportPalette,
   showTooltip
-} from "./chunk-6XLMTAEX.js";
+} from "./chunk-YIHRLY55.js";
 import {
   parseTimelineDate
-} from "./chunk-BQO24BDM.js";
+} from "./chunk-O3HRF25Z.js";
 import {
   parseFamily
-} from "./chunk-R6EGUTIV.js";
-import {
-  parseGantt
-} from "./chunk-PVWIBKV2.js";
+} from "./chunk-J467QBZF.js";
 import {
   parseClock
-} from "./chunk-NXU4N5WT.js";
+} from "./chunk-6OUMYNAJ.js";
 import {
   parseCountdown
-} from "./chunk-KBEWVCK3.js";
+} from "./chunk-EBJLT7PH.js";
 import {
   parseCycle
-} from "./chunk-NPDVWFAQ.js";
+} from "./chunk-PLQZJZ2K.js";
 import {
   parseBracket
-} from "./chunk-2WQ3YZMN.js";
+} from "./chunk-3IUMSK72.js";
 import {
   layoutBracket
-} from "./chunk-ZI6WC24V.js";
+} from "./chunk-ZBJV4KNU.js";
 import {
   parseC4
-} from "./chunk-IXHWS2HI.js";
+} from "./chunk-5WZYJC2P.js";
 import {
   parseBlock
-} from "./chunk-BRGRIZQB.js";
+} from "./chunk-RC6PISCK.js";
 import {
   isBlockNode
 } from "./chunk-XSVWUOUZ.js";
 import {
   parseBody
-} from "./chunk-JXGSTBW6.js";
+} from "./chunk-FK6HZYGK.js";
 import {
   parseBoxesAndLines
-} from "./chunk-4UVCTLRH.js";
+} from "./chunk-SNDCXT5R.js";
 import {
   ScaleContext
 } from "./chunk-24YPR5EH.js";
+import {
+  injectToggleCue,
+  stripFoldAffordance
+} from "./chunk-LRTSTDJ6.js";
 import {
   legendInlineSupported
-} from "./chunk-UIEKW4SG.js";
+} from "./chunk-REKLKGR6.js";
 import {
   GRID_DASH,
   scaleDash
-} from "./chunk-XCKNFFKM.js";
+} from "./chunk-WH6E6SHC.js";
 import {
   compactNumber
-} from "./chunk-JILEYZ2V.js";
+} from "./chunk-VVL2KKG4.js";
 import {
   parseRaci
-} from "./chunk-KRPLP5LP.js";
+} from "./chunk-6PUBFB6D.js";
+import {
+  parseSitemap
+} from "./chunk-KMB754DO.js";
+import {
+  parsePert
+} from "./chunk-CUTEHGXO.js";
 import {
   parseLiveLink
-} from "./chunk-KBDMEOLI.js";
+} from "./chunk-65JFUANT.js";
 import {
   parseSequenceDgmo
-} from "./chunk-VSAKEMDD.js";
+} from "./chunk-ROH4LYBL.js";
 import {
   parseOrg
-} from "./chunk-5OTA2PUH.js";
-import {
-  parseSitemap
-} from "./chunk-ZECJ7Q6C.js";
+} from "./chunk-YCIBBVI2.js";
 import {
-  parsePert
-} from "./chunk-CDM6XMOT.js";
+  parseState
+} from "./chunk-WXGFB2O2.js";
 import {
   parseFlowchart
-} from "./chunk-IY62DXT2.js";
+} from "./chunk-IAM3IDL4.js";
 import {
-  parseState
-} from "./chunk-LJGE43SG.js";
+  parseERDiagram
+} from "./chunk-PSNRB75I.js";
 import {
   choosePalette,
   extractPaletteDirective
 } from "./chunk-CYTFO2LF.js";
-import {
-  parseERDiagram
-} from "./chunk-S4SJ4LLY.js";
 import {
   parseClassDiagram
-} from "./chunk-5XBYLYYI.js";
+} from "./chunk-H7DZYHQF.js";
 import {
   getPalette
 } from "./chunk-FMAVHTYB.js";
@@ -181,15 +191,15 @@ import {
 } from "./chunk-ICLB27PZ.js";
 import {
   parseWireframe
-} from "./chunk-GI5R5B3S.js";
+} from "./chunk-VVZDBUHA.js";
 import {
   resolveActiveTagGroup,
   tagAttrKey
-} from "./chunk-4SACN2C5.js";
+} from "./chunk-KW3CC7SB.js";
 import {
   measureText,
   wrapTextToWidth
-} from "./chunk-KAO7JL4I.js";
+} from "./chunk-PU5X3P3T.js";
 import {
   getSeriesColors,
   mix,
@@ -200,6 +210,686 @@ import {
   makeDgmoError
 } from "./chunk-BYU54C3S.js";
 
+// src/utils/export-fit.ts
+var EXPORT_FIT_PAD = 24;
+var EXPORT_FIT_MIN_TRIM = EXPORT_FIT_PAD * 2;
+var TEXT_WIDTH_SAFETY = 1.15;
+var MARKER_ALLOWANCE = 12;
+var DEFAULT_FONT_SIZE = 16;
+var NON_RENDERING = /* @__PURE__ */ new Set([
+  "defs",
+  "clippath",
+  "mask",
+  "marker",
+  "pattern",
+  "symbol",
+  "lineargradient",
+  "radialgradient",
+  "filter",
+  "style",
+  "title",
+  "desc",
+  "metadata",
+  "script"
+]);
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function multiply(p, q) {
+  return [
+    p[0] * q[0] + p[2] * q[1],
+    p[1] * q[0] + p[3] * q[1],
+    p[0] * q[2] + p[2] * q[3],
+    p[1] * q[2] + p[3] * q[3],
+    p[0] * q[4] + p[2] * q[5] + p[4],
+    p[1] * q[4] + p[3] * q[5] + p[5]
+  ];
+}
+var NUM_RE = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g;
+function nums(s) {
+  return (s.match(NUM_RE) ?? []).map(Number);
+}
+function parseTransform(value) {
+  let m = IDENTITY;
+  const re = /\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)\s*,?/gy;
+  let consumed = 0;
+  for (const t of value.matchAll(re)) {
+    consumed = (t.index ?? 0) + t[0].length;
+    const a = nums(t[2]);
+    let local;
+    switch (t[1]) {
+      case "matrix":
+        if (a.length !== 6) return null;
+        local = a;
+        break;
+      case "translate":
+        if (a.length < 1 || a.length > 2) return null;
+        local = [1, 0, 0, 1, a[0], a[1] ?? 0];
+        break;
+      case "scale":
+        if (a.length < 1 || a.length > 2) return null;
+        local = [a[0], 0, 0, a[1] ?? a[0], 0, 0];
+        break;
+      case "rotate": {
+        if (a.length !== 1 && a.length !== 3) return null;
+        const r = a[0] * Math.PI / 180;
+        const c = Math.cos(r);
+        const s = Math.sin(r);
+        const rot = [c, s, -s, c, 0, 0];
+        if (a.length === 3) {
+          const [, cx, cy] = a;
+          local = multiply(multiply([1, 0, 0, 1, cx, cy], rot), [
+            1,
+            0,
+            0,
+            1,
+            -cx,
+            -cy
+          ]);
+        } else local = rot;
+        break;
+      }
+      case "skewX":
+        if (a.length !== 1) return null;
+        local = [1, 0, Math.tan(a[0] * Math.PI / 180), 1, 0, 0];
+        break;
+      default:
+        if (a.length !== 1) return null;
+        local = [1, Math.tan(a[0] * Math.PI / 180), 0, 1, 0, 0];
+    }
+    m = multiply(m, local);
+  }
+  return value.slice(consumed).trim() === "" ? m : null;
+}
+function pathBox(d) {
+  let i = 0;
+  const n = d.length;
+  const box = {
+    x0: Infinity,
+    y0: Infinity,
+    x1: -Infinity,
+    y1: -Infinity
+  };
+  const add = (x, y) => {
+    if (x < box.x0) box.x0 = x;
+    if (x > box.x1) box.x1 = x;
+    if (y < box.y0) box.y0 = y;
+    if (y > box.y1) box.y1 = y;
+  };
+  const skipSep = () => {
+    while (i < n && /[\s,]/.test(d[i])) i++;
+  };
+  const numAt = () => {
+    skipSep();
+    const m = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/y;
+    m.lastIndex = i;
+    const r = m.exec(d);
+    if (!r) return null;
+    i += r[0].length;
+    return Number(r[0]);
+  };
+  const flagAt = () => {
+    skipSep();
+    const c = d[i];
+    if (c !== "0" && c !== "1") return null;
+    i++;
+    return c === "1" ? 1 : 0;
+  };
+  const moreNumbers = () => {
+    skipSep();
+    return i < n && /[-+.\d]/.test(d[i]);
+  };
+  let cx = 0;
+  let cy = 0;
+  let sx = 0;
+  let sy = 0;
+  let cmd = "";
+  while (true) {
+    skipSep();
+    if (i >= n) break;
+    const c = d[i];
+    if (/[MmLlHhVvCcSsQqTtAaZz]/.test(c)) {
+      cmd = c;
+      i++;
+    } else if (!cmd || cmd === "Z" || cmd === "z" || !/[-+.\d]/.test(c)) {
+      return null;
+    }
+    const rel = cmd === cmd.toLowerCase();
+    const up = cmd.toUpperCase();
+    if (up === "Z") {
+      cx = sx;
+      cy = sy;
+      continue;
+    }
+    const arity = {
+      M: 2,
+      L: 2,
+      T: 2,
+      H: 1,
+      V: 1,
+      C: 6,
+      S: 4,
+      Q: 4,
+      A: 7
+    };
+    do {
+      const k = arity[up];
+      const a = [];
+      for (let j = 0; j < k; j++) {
+        const v = up === "A" && (j === 3 || j === 4) ? flagAt() : numAt();
+        if (v === null) return null;
+        a.push(v);
+      }
+      const ox = rel ? cx : 0;
+      const oy = rel ? cy : 0;
+      if (up === "H") {
+        cx = a[0] + ox;
+      } else if (up === "V") {
+        cy = a[0] + oy;
+      } else if (up === "A") {
+        const x2 = a[5] + ox;
+        const y2 = a[6] + oy;
+        arcExtent(cx, cy, a[0], a[1], a[2], a[3], a[4], x2, y2, add);
+        cx = x2;
+        cy = y2;
+      } else {
+        for (let j = 0; j + 1 < k; j += 2) add(a[j] + ox, a[j + 1] + oy);
+        cx = a[k - 2] + ox;
+        cy = a[k - 1] + oy;
+      }
+      add(cx, cy);
+      if (up === "M") {
+        sx = cx;
+        sy = cy;
+      }
+    } while (moreNumbers());
+    if (cmd === "M") cmd = "L";
+    else if (cmd === "m") cmd = "l";
+  }
+  return box.x0 <= box.x1 ? box : null;
+}
+function arcExtent(x1, y1, rxIn, ryIn, rotDeg, large, sweep, x2, y2, add) {
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0 || x1 === x2 && y1 === y2) return;
+  const phi = rotDeg * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const xp = cos * dx + sin * dy;
+  const yp = -sin * dx + cos * dy;
+  const lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+  const den = rx * rx * yp * yp + ry * ry * xp * xp;
+  const factor = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den || 0));
+  const cxp = factor * rx * yp / ry;
+  const cyp = -factor * ry * xp / rx;
+  const ccx = cos * cxp - sin * cyp + (x1 + x2) / 2;
+  const ccy = sin * cxp + cos * cyp + (y1 + y2) / 2;
+  const r = Math.max(rx, ry);
+  add(ccx - r, ccy - r);
+  add(ccx + r, ccy + r);
+}
+function attrOf(attrs, name) {
+  const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*("([^"]*)"|'([^']*)')`).exec(
+    attrs
+  );
+  return m ? m[2] ?? m[3] ?? "" : null;
+}
+function styleOf(attrs, prop2) {
+  const style = attrOf(attrs, "style");
+  if (!style) return null;
+  const m = new RegExp(`(?:^|;)\\s*${prop2}\\s*:\\s*([^;]+)`, "i").exec(style);
+  return m ? m[1].trim() : null;
+}
+function prop(attrs, name) {
+  return styleOf(attrs, name) ?? attrOf(attrs, name);
+}
+function lengthOf(v, basis, fontSize) {
+  if (v === null) return null;
+  const m = /^\s*([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)\s*(px|em|%|pt)?/.exec(v);
+  if (!m) return null;
+  const n = Number(m[1]);
+  switch (m[2]) {
+    case "em":
+      return n * fontSize;
+    case "%":
+      return n / 100 * basis;
+    case "pt":
+      return n * 4 / 3;
+    default:
+      return n;
+  }
+}
+function firstLength(v, basis, fontSize) {
+  if (v === null) return null;
+  return lengthOf(v.trim().split(/[\s,]+/)[0] ?? "", basis, fontSize);
+}
+function verticalEm(baseline) {
+  switch (baseline) {
+    case "middle":
+    case "central":
+    case "mathematical":
+      return [0.65, 0.65];
+    case "hanging":
+    case "text-before-edge":
+    case "before-edge":
+      return [0.1, 1.25];
+    case "text-after-edge":
+    case "after-edge":
+    case "ideographic":
+      return [1.3, 0.1];
+    case "auto":
+    case "alphabetic":
+    case "baseline":
+    case "":
+      return [1, 0.3];
+    default:
+      return [1.3, 1.25];
+  }
+}
+var SHAPES = /* @__PURE__ */ new Set([
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polygon",
+  "polyline",
+  "path"
+]);
+var NO_PAINT = /^(?:none|transparent)$/i;
+function zero(v) {
+  return v !== null && Number(v) === 0;
+}
+function paintsNothing(attrs, frame) {
+  if (zero(prop(attrs, "opacity"))) return true;
+  const fill = prop(attrs, "fill");
+  const noFill = frame.tag === "line" || fill !== null && NO_PAINT.test(fill.trim()) || zero(prop(attrs, "fill-opacity"));
+  const noStroke = frame.stroke === null || NO_PAINT.test(frame.stroke.trim()) || zero(prop(attrs, "stroke-opacity")) || frame.strokeW === 0;
+  return noFill && noStroke;
+}
+function cssCanSetPaint(svg) {
+  for (const m of svg.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/g)) {
+    let css = m[1];
+    for (; ; ) {
+      const at = css.search(/@media\s*\(\s*hover\s*:\s*hover\s*\)\s*\{/);
+      if (at < 0) break;
+      let i = css.indexOf("{", at) + 1;
+      for (let depth = 1; i < css.length && depth > 0; i++) {
+        if (css[i] === "{") depth++;
+        else if (css[i] === "}") depth--;
+      }
+      css = css.slice(0, at) + css.slice(i);
+    }
+    for (const r of css.matchAll(/([^{}]*)\{([^{}]*)\}/g)) {
+      if (r[1].includes(":hover")) continue;
+      if (/(?:^|[;\s])(?:fill|stroke|opacity|fill-opacity|stroke-opacity)\s*:/.test(
+        r[2]
+      ))
+        return true;
+    }
+  }
+  return false;
+}
+function decodeText(raw) {
+  return raw.replace(/&(?:#\d+|#x[0-9a-f]+|[a-z]+);/gi, "M").replace(/\s+/g, " ");
+}
+function measureSvgContent(svg) {
+  const canvas = readViewBox(svg);
+  const cw = canvas?.width ?? 0;
+  const ch = canvas?.height ?? 0;
+  const out = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+  let complete = true;
+  const addBox = (m, b, inflate) => {
+    const xs = [b.x0 - inflate, b.x1 + inflate];
+    const ys = [b.y0 - inflate, b.y1 + inflate];
+    for (const x of xs)
+      for (const y of ys) {
+        const tx = m[0] * x + m[2] * y + m[4];
+        const ty = m[1] * x + m[3] * y + m[5];
+        if (!Number.isFinite(tx) || !Number.isFinite(ty)) {
+          complete = false;
+          continue;
+        }
+        if (tx < out.x0) out.x0 = tx;
+        if (tx > out.x1) out.x1 = tx;
+        if (ty < out.y0) out.y0 = ty;
+        if (ty > out.y1) out.y1 = ty;
+      }
+  };
+  const pathsById = /* @__PURE__ */ new Map();
+  for (const m of svg.matchAll(/<path\b([^>]*)>/g)) {
+    const id = attrOf(m[1], "id");
+    const d = attrOf(m[1], "d");
+    if (id && d) pathsById.set(id, d);
+  }
+  const trustNoPaint = !cssCanSetPaint(svg);
+  const stack = [];
+  let text = null;
+  const flushChunk = () => {
+    if (!text || text.pieces.length === 0) return;
+    const right = Math.max(...text.pieces.map((p) => p.x1));
+    const w = right - text.chunkX;
+    const shift = text.chunkAnchor === "middle" ? -w / 2 : text.chunkAnchor === "end" ? -w : 0;
+    for (const p of text.pieces) {
+      const [up, down] = verticalEm(p.baseline);
+      addBox(
+        text.m,
+        {
+          x0: p.x0 + shift,
+          x1: p.x1 + shift,
+          y0: p.y - up * p.fontSize,
+          y1: p.y + down * p.fontSize
+        },
+        0
+      );
+    }
+    text.pieces = [];
+  };
+  const tagRe = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<[?!][^>]*>|<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|([^<]+)/g;
+  for (const t of svg.matchAll(tagRe)) {
+    const [, close, rawName, attrs = "", selfClose, chars] = t;
+    const parent = stack[stack.length - 1];
+    if (chars !== void 0) {
+      if (!text || !parent || parent.skip) continue;
+      const s = decodeText(chars);
+      if (s.trim() === "") continue;
+      const fs = parent.fontSize;
+      let w = measureText(s, fs, { bold: parent.bold }) * TEXT_WIDTH_SAFETY;
+      if (parent.mono) w = Math.max(w, s.length * fs * 0.62);
+      text.pieces.push({
+        x0: text.curX,
+        x1: text.curX + w,
+        y: text.curY,
+        fontSize: fs,
+        baseline: parent.baseline
+      });
+      text.curX += w;
+      continue;
+    }
+    if (rawName === void 0) continue;
+    const name = rawName.toLowerCase();
+    if (close) {
+      for (let k = stack.length - 1; k >= 0; k--) {
+        if (stack[k].tag === name) {
+          stack.length = k;
+          break;
+        }
+      }
+      if (name === "text" && text) {
+        flushChunk();
+        text = null;
+      }
+      continue;
+    }
+    const isRoot = stack.length === 0;
+    const base = parent ?? {
+      tag: "",
+      m: IDENTITY,
+      fontSize: DEFAULT_FONT_SIZE,
+      anchor: "start",
+      baseline: "",
+      bold: false,
+      mono: false,
+      strokeW: 1,
+      stroke: null,
+      skip: false
+    };
+    const skip = base.skip || NON_RENDERING.has(name);
+    let m = base.m;
+    if (!skip) {
+      if (/(?:^|[;\s"])transform\s*:/i.test(attrOf(attrs, "style") ?? "")) {
+        complete = false;
+      }
+      const tr = attrOf(attrs, "transform");
+      if (tr !== null && !isRoot) {
+        const local = parseTransform(tr);
+        if (local === null) complete = false;
+        else m = multiply(m, local);
+      }
+    }
+    const fsRaw = prop(attrs, "font-size");
+    let fontSize = base.fontSize;
+    if (fsRaw !== null) {
+      const v = lengthOf(fsRaw, base.fontSize, base.fontSize);
+      fontSize = v !== null && v > 0 ? v : base.fontSize * 2;
+    }
+    const weight = prop(attrs, "font-weight");
+    const family = prop(attrs, "font-family");
+    const sw = lengthOf(prop(attrs, "stroke-width"), 1, fontSize);
+    const frame = {
+      tag: name,
+      m,
+      fontSize,
+      anchor: prop(attrs, "text-anchor") ?? base.anchor,
+      baseline: prop(attrs, "dominant-baseline") ?? prop(attrs, "alignment-baseline") ?? base.baseline,
+      bold: weight !== null ? /bold|bolder|[6-9]00/.test(weight) : base.bold,
+      mono: family !== null ? /mono|courier/i.test(family) : base.mono,
+      strokeW: sw !== null && sw >= 0 ? sw : base.strokeW,
+      stroke: prop(attrs, "stroke") ?? base.stroke,
+      skip
+    };
+    if (trustNoPaint && !skip && !isRoot && SHAPES.has(name) && paintsNothing(attrs, frame)) {
+    } else if (!skip && !isRoot) {
+      const num = (k, basis) => lengthOf(attrOf(attrs, k), basis, fontSize);
+      const inflate = frame.strokeW / 2 + (/marker-(?:start|mid|end)/.test(attrs) ? MARKER_ALLOWANCE : 0);
+      switch (name) {
+        case "rect":
+        case "image":
+        case "foreignobject":
+        case "svg": {
+          const cls = attrOf(attrs, "class") ?? "";
+          if (name === "rect" && /\bdgmo-canvas-bg\b/.test(cls)) break;
+          const x = num("x", cw) ?? 0;
+          const y = num("y", ch) ?? 0;
+          const w = num("width", cw);
+          const h = num("height", ch);
+          if (w === null || h === null) {
+            if (name !== "rect") complete = false;
+            break;
+          }
+          addBox(m, { x0: x, y0: y, x1: x + w, y1: y + h }, inflate);
+          if (name === "svg") frame.skip = true;
+          break;
+        }
+        case "circle":
+        case "ellipse": {
+          const cx = num("cx", cw) ?? 0;
+          const cy = num("cy", ch) ?? 0;
+          const rx = name === "circle" ? num("r", cw) : num("rx", cw);
+          const ry = name === "circle" ? rx : num("ry", ch);
+          if (rx === null || ry === null) break;
+          addBox(
+            m,
+            { x0: cx - rx, y0: cy - ry, x1: cx + rx, y1: cy + ry },
+            inflate
+          );
+          break;
+        }
+        case "line": {
+          const x1 = num("x1", cw) ?? 0;
+          const y1 = num("y1", ch) ?? 0;
+          const x2 = num("x2", cw) ?? 0;
+          const y2 = num("y2", ch) ?? 0;
+          addBox(
+            m,
+            {
+              x0: Math.min(x1, x2),
+              y0: Math.min(y1, y2),
+              x1: Math.max(x1, x2),
+              y1: Math.max(y1, y2)
+            },
+            inflate
+          );
+          break;
+        }
+        case "polygon":
+        case "polyline": {
+          const p = nums(attrOf(attrs, "points") ?? "");
+          if (p.length < 2) break;
+          const b = {
+            x0: Infinity,
+            y0: Infinity,
+            x1: -Infinity,
+            y1: -Infinity
+          };
+          for (let k = 0; k + 1 < p.length; k += 2) {
+            b.x0 = Math.min(b.x0, p[k]);
+            b.x1 = Math.max(b.x1, p[k]);
+            b.y0 = Math.min(b.y0, p[k + 1]);
+            b.y1 = Math.max(b.y1, p[k + 1]);
+          }
+          addBox(m, b, inflate);
+          break;
+        }
+        case "path": {
+          const d = attrOf(attrs, "d");
+          if (!d || d.trim() === "" || d.trim().toLowerCase() === "none") break;
+          const b = pathBox(d);
+          if (b === null) complete = false;
+          else addBox(m, b, inflate);
+          break;
+        }
+        case "use":
+          complete = false;
+          break;
+        case "text": {
+          flushChunk();
+          const x = firstLength(attrOf(attrs, "x"), cw, fontSize) ?? 0;
+          const y = firstLength(attrOf(attrs, "y"), ch, fontSize) ?? 0;
+          const dx = firstLength(attrOf(attrs, "dx"), cw, fontSize) ?? 0;
+          const dy = firstLength(attrOf(attrs, "dy"), ch, fontSize) ?? 0;
+          text = {
+            m,
+            curX: x + dx,
+            curY: y + dy,
+            chunkX: x + dx,
+            chunkAnchor: frame.anchor,
+            pieces: []
+          };
+          break;
+        }
+        case "tspan": {
+          if (!text) break;
+          const x = firstLength(attrOf(attrs, "x"), cw, fontSize);
+          const y = firstLength(attrOf(attrs, "y"), ch, fontSize);
+          const dx = firstLength(attrOf(attrs, "dx"), cw, fontSize) ?? 0;
+          const dy = firstLength(attrOf(attrs, "dy"), ch, fontSize) ?? 0;
+          if (x !== null || y !== null) {
+            flushChunk();
+            if (x !== null) text.curX = x;
+            if (y !== null) text.curY = y;
+            text.curX += dx;
+            text.curY += dy;
+            text.chunkX = text.curX;
+            text.chunkAnchor = frame.anchor;
+          } else {
+            text.curX += dx;
+            text.curY += dy;
+          }
+          break;
+        }
+        case "textpath": {
+          if (!text) break;
+          const href = (attrOf(attrs, "href") ?? attrOf(attrs, "xlink:href") ?? "").replace(/^#/, "");
+          const d = pathsById.get(href);
+          const b = d ? pathBox(d) : null;
+          if (b === null) complete = false;
+          else addBox(text.m, b, fontSize * 1.3);
+          frame.skip = true;
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    if (!selfClose) stack.push(frame);
+    else if (name === "text") {
+      flushChunk();
+      text = null;
+    }
+  }
+  const box = out.x0 <= out.x1 && out.y0 <= out.y1 ? out : null;
+  return { box, complete };
+}
+function fmt(n) {
+  return String(Math.round(n * 1e3) / 1e3);
+}
+function setRootAttr(root, name, value) {
+  const re = new RegExp(`(\\s${name}=)"[^"]*"`);
+  return re.test(root) ? root.replace(re, `$1"${value}"`) : root.replace(/^<svg\b/, `<svg ${name}="${value}"`);
+}
+function fitSvgToContent(svg, opts = {}) {
+  const rootMatch = /<svg\b(?:[^>"']|"[^"]*"|'[^']*')*>/.exec(svg);
+  if (!rootMatch) return svg;
+  const root = rootMatch[0];
+  if (/\sdata-export-(?:width|height)=/.test(root)) return svg;
+  const canvas = readViewBox(svg);
+  if (!canvas) return svg;
+  const { box, complete } = measureSvgContent(svg);
+  if (!complete || !box) return svg;
+  const cx0 = canvas.x;
+  const cy0 = canvas.y;
+  const cx1 = canvas.x + canvas.width;
+  const cy1 = canvas.y + canvas.height;
+  let x0 = Math.max(cx0, Math.floor(box.x0 - EXPORT_FIT_PAD));
+  let x1 = Math.min(cx1, Math.ceil(box.x1 + EXPORT_FIT_PAD));
+  let y0 = Math.max(cy0, Math.floor(box.y0 - EXPORT_FIT_PAD));
+  let y1 = Math.min(cy1, Math.ceil(box.y1 + EXPORT_FIT_PAD));
+  if (x1 <= x0 || y1 <= y0) return svg;
+  const minW = Math.min(canvas.width, MIN_CANVAS_WIDTH);
+  if (x1 - x0 < minW) {
+    const grow = minW - (x1 - x0);
+    x0 = Math.max(cx0, x0 - Math.floor(grow / 2));
+    x1 = x0 + minW;
+    if (x1 > cx1) {
+      x1 = cx1;
+      x0 = cx1 - minW;
+    }
+  }
+  const trimX = canvas.width - (x1 - x0) >= EXPORT_FIT_MIN_TRIM;
+  const trimY = canvas.height - (y1 - y0) >= EXPORT_FIT_MIN_TRIM;
+  if (!trimX && !trimY) return svg;
+  if (!trimX) {
+    x0 = cx0;
+    x1 = cx1;
+  }
+  if (!trimY) {
+    y0 = cy0;
+    y1 = cy1;
+  }
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const rootW = Number(attrOf(root.slice(4), "width"));
+  const rootH = Number(attrOf(root.slice(4), "height"));
+  const sx = rootW > 0 ? rootW / canvas.width : 1;
+  const sy = rootH > 0 ? rootH / canvas.height : 1;
+  let outW = w * sx;
+  let outH = h * sy;
+  const scales = [];
+  if (opts.width && opts.width > 0 && Math.abs(rootW - opts.width) <= 1)
+    scales.push(opts.width / w);
+  if (opts.height && opts.height > 0 && Math.abs(rootH - opts.height) <= 1)
+    scales.push(opts.height / h);
+  if (scales.length > 0) {
+    const s = Math.min(...scales);
+    outW = w * s;
+    outH = h * s;
+  }
+  let newRoot = setRootAttr(root, "viewBox", `${x0} ${y0} ${w} ${h}`);
+  if (rootW > 0) newRoot = setRootAttr(newRoot, "width", fmt(outW));
+  if (rootH > 0) newRoot = setRootAttr(newRoot, "height", fmt(outH));
+  if (trimY) newRoot = newRoot.replace(/\sdata-content-height="[^"]*"/, "");
+  const body = svg.slice(rootMatch.index + root.length).replace(
+    /<rect\b[^>]*\bclass="[^"]*\bdgmo-canvas-bg\b[^"]*"[^>]*>/g,
+    (r) => r.replace(/(\sx=)"[^"]*"/, `$1"${x0}"`).replace(/(\sy=)"[^"]*"/, `$1"${y0}"`).replace(/(\swidth=)"[^"]*"/, `$1"${w}"`).replace(/(\sheight=)"[^"]*"/, `$1"${h}"`)
+  );
+  return svg.slice(0, rootMatch.index) + newRoot + body;
+}
+
 // src/arc/renderer.ts
 import * as d3Scale from "d3-scale";
 import * as d3Selection from "d3-selection";
@@ -345,8 +1035,18 @@ function renderArcDiagram(container, parsed, palette, isDark, onClickItem, expor
   if (ctx.isBelowFloor) {
     svg.attr("width", "100%");
   }
+  const g = svg.append("g");
+  const titleExtra = renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem,
+    2
+  );
   const margin = {
-    top: sMarginTop,
+    top: sMarginTop + titleExtra,
     right: sMarginRight,
     bottom: sMarginBottom,
     left: sMarginLeft
@@ -370,15 +1070,7 @@ function renderArcDiagram(container, parsed, palette, isDark, onClickItem, expor
   const values = links.map((l) => l.value);
   const [minVal, maxVal] = d3Array.extent(values);
   const strokeScale = d3Scale.scaleLinear().domain([minVal, maxVal]).range([sStrokeMin, sStrokeMax]);
-  const g = svg.append("g").attr("transform", `translate(${margin.left},${margin.top})`);
-  renderChartTitle(
-    svg,
-    title,
-    parsed.titleLineNumber,
-    width,
-    textColor,
-    onClickItem
-  );
+  g.attr("transform", `translate(${margin.left},${margin.top})`);
   const neighbors = /* @__PURE__ */ new Map();
   for (const node of nodes) neighbors.set(node, /* @__PURE__ */ new Set());
   for (const link of links) {
@@ -639,6 +1331,64 @@ function renderArcDiagram(container, parsed, palette, isDark, onClickItem, expor
   }
 }
 
+// src/pert/export.ts
+function collapsedPertGroupIdsFromSource(parsed) {
+  return new Set(parsed.groups.filter((g) => g.collapsed).map((g) => g.id));
+}
+function unionCollapsedPertGroups(parsed, runtime) {
+  const set = collapsedPertGroupIdsFromSource(parsed);
+  for (const id of runtime ?? []) set.add(id);
+  return set;
+}
+async function exportPert(ctx) {
+  const { content, theme, palette, viewState } = ctx;
+  const { parsePert: parsePert2 } = await import("./parser-YV4RBHG7.js");
+  const { analyzePert } = await import("./analyzer-G7PGOT3V.js");
+  const { relayoutPert } = await import("./layout-GC5XX2RH.js");
+  const { renderPert, measurePertAnalysisBlock } = await import("./renderer-M2467III.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const pertParsed = parsePert2(content, { palette: effectivePalette });
+  if (pertParsed.error || pertParsed.activities.length === 0) return "";
+  const pertResolved = analyzePert(pertParsed);
+  const collapsedIds = unionCollapsedPertGroups(pertParsed, viewState?.cg);
+  const pertLayout = relayoutPert(pertResolved, {}, collapsedIds);
+  const hasTitle = !!pertParsed.title && !pertParsed.options.noTitle;
+  const hasSubtitle = pertResolved.projectSubtitle !== null;
+  const titleHeight = hasTitle ? 80 : hasSubtitle ? 50 : 0;
+  const PERT_PADDING = 20;
+  const analysisOn = viewState?.an ?? !pertParsed.options.noAnalysis;
+  const fieldLabelsOn = viewState?.fl === true;
+  const exportW = pertLayout.width + PERT_PADDING * 2;
+  const analysisMeasured = measurePertAnalysisBlock(
+    pertResolved,
+    exportW - 2 * PERT_PADDING,
+    {
+      showTornado: analysisOn,
+      showScurve: analysisOn,
+      showFieldLegend: fieldLabelsOn
+    }
+  );
+  const exportH = pertLayout.height + PERT_PADDING * 2 + titleHeight + analysisMeasured.height;
+  const container = createExportContainer(exportW, exportH);
+  renderPert(
+    container,
+    pertResolved,
+    pertLayout,
+    effectivePalette,
+    ctx.isDark,
+    {
+      title: hasTitle ? pertParsed.title : null,
+      subtitle: pertResolved.projectSubtitle,
+      exportDims: { width: exportW, height: exportH },
+      showTornado: analysisOn,
+      showScurve: analysisOn,
+      showFieldLegend: fieldLabelsOn,
+      collapsedGroupIds: [...collapsedIds]
+    }
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+
 // src/quadrant/renderer.ts
 import * as d3Scale2 from "d3-scale";
 import * as d3Selection2 from "d3-selection";
@@ -670,10 +1420,19 @@ function renderQuadrant(container, parsed, palette, isDark, onClickItem, exportD
     palette.colors.yellow,
     palette.colors.purple
   ];
+  const titleExtra = renderChartTitle(
+    svg,
+    title,
+    quadrantTitleLineNumber,
+    width,
+    textColor,
+    onClickItem,
+    2
+  );
   const hasXAxis = !!quadrantXAxis;
   const hasYAxis = !!quadrantYAxis;
   const margin = {
-    top: title ? ctx.aesthetic(60) : ctx.aesthetic(30),
+    top: (title ? ctx.aesthetic(60) : ctx.aesthetic(30)) + titleExtra,
     right: ctx.aesthetic(30),
     bottom: hasXAxis ? ctx.aesthetic(70) : ctx.aesthetic(40),
     left: hasYAxis ? ctx.aesthetic(80) : ctx.aesthetic(40)
@@ -682,14 +1441,6 @@ function renderQuadrant(container, parsed, palette, isDark, onClickItem, exportD
   const chartHeight = height - margin.top - margin.bottom;
   const xScale = d3Scale2.scaleLinear().domain([0, 1]).range([0, chartWidth]);
   const yScale = d3Scale2.scaleLinear().domain([0, 1]).range([chartHeight, 0]);
-  renderChartTitle(
-    svg,
-    title,
-    quadrantTitleLineNumber,
-    width,
-    textColor,
-    onClickItem
-  );
   const chartG = svg.append("g").attr("transform", `translate(${margin.left}, ${margin.top})`);
   const bg = themeBaseBg(palette, isDark);
   const getQuadrantColor = (label, defaultIdx) => {
@@ -1036,6 +1787,17 @@ function renderSlopeChart(container, parsed, palette, isDark, onClickItem, expor
   if (ctx.isBelowFloor) {
     svg.attr("width", "100%");
   }
+  const g = svg.append("g");
+  const titleExtra = renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem,
+    2
+  );
+  const sPlotTop = sMarginTop + titleExtra;
   const maxLabelText = data.reduce((longest, item) => {
     const text = `${item.values[item.values.length - 1]} \u2014 ${item.label}`;
     return text.length > longest.length ? text : longest;
@@ -1047,22 +1809,14 @@ function renderSlopeChart(container, parsed, palette, isDark, onClickItem, expor
     maxRightMargin
   );
   const innerWidth = width - sMarginLeft - rightMargin;
-  const innerHeight = height - sMarginTop - sMarginBottom;
+  const innerHeight = height - sPlotTop - sMarginBottom;
   const allValues2 = data.flatMap((d) => d.values);
   const [minVal, maxVal] = d3Array2.extent(allValues2);
   const valuePadding = (maxVal - minVal) * 0.1 || 1;
   const yScale = d3Scale3.scaleLinear().domain([minVal - valuePadding, maxVal + valuePadding]).range([innerHeight, 0]);
   const xScale = d3Scale3.scalePoint().domain(periods).range([0, innerWidth]).padding(0);
-  const g = svg.append("g").attr("transform", `translate(${sMarginLeft},${sMarginTop})`);
+  g.attr("transform", `translate(${sMarginLeft},${sPlotTop})`);
   const tooltip = createTooltip(container, palette, isDark);
-  renderChartTitle(
-    svg,
-    title,
-    parsed.titleLineNumber,
-    width,
-    textColor,
-    onClickItem
-  );
   for (const period of periods) {
     const x = xScale(period);
     g.append("text").attr("x", x).attr("y", -sPeriodHeaderY).attr("text-anchor", "middle").attr("fill", textColor).attr("font-size", sPeriodFont).attr("font-weight", "bold").text(period);
@@ -1262,11 +2016,23 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
   const n = vennSets.length;
   const idealWidth = n === 2 ? 500 : 600;
   const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
-  const sTitleHeight = title ? ctx.aesthetic(40) : 0;
   svg.attr("preserveAspectRatio", "xMidYMid meet");
   if (ctx.isBelowFloor) {
     svg.attr("width", "100%");
   }
+  svg.append("style").text(
+    "circle:focus, circle:focus-visible { outline-solid: none !important; }"
+  );
+  const titleExtra = renderChartTitle(
+    svg,
+    title,
+    parsed.titleLineNumber,
+    width,
+    textColor,
+    onClickItem,
+    2
+  );
+  const sTitleHeight = title ? ctx.aesthetic(40) + titleExtra : 0;
   const BASE_R = 100;
   const OVERLAP_DISTANCE = BASE_R * 1.4;
   let rawCircles;
@@ -1394,17 +2160,6 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
     marginBottom
   ).map((c) => ({ ...c, y: c.y + sTitleHeight }));
   const scaledR = circles[0].r;
-  svg.append("style").text(
-    "circle:focus, circle:focus-visible { outline-solid: none !important; }"
-  );
-  renderChartTitle(
-    svg,
-    title,
-    parsed.titleLineNumber,
-    width,
-    textColor,
-    onClickItem
-  );
   const circleEls = [];
   const circleGroup = svg.append("g");
   circles.forEach((c, i) => {
@@ -1512,6 +2267,19 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
   const INTERNAL_PAD = ctx.aesthetic(12);
   const labelGroup = svg.append("g");
   const setLabelBBoxes = circles.map(() => null);
+  const tripleLeader = n === 3 && vennOverlaps.some((ov) => ov.label && new Set(ov.sets).size === 3) ? regionCentroid(circles, [true, true, true]) : null;
+  const LEADER_CLEARANCE = ctx.structural(6);
+  const TRIPLE_DODGE = Math.PI / 6;
+  const gapToTripleLeader = (x1, y1, x2, y2) => {
+    if (!tripleLeader || Math.min(y1, y2) >= tripleLeader.y) return Infinity;
+    const lo = Math.min(x1, x2);
+    const hi = Math.max(x1, x2);
+    if (tripleLeader.x >= lo && tripleLeader.x <= hi) return 0;
+    return Math.min(
+      Math.abs(lo - tripleLeader.x),
+      Math.abs(hi - tripleLeader.x)
+    );
+  };
   circles.forEach((c, i) => {
     const text = vennSets[i].name;
     const inside = circles.map((_, j) => j === i);
@@ -1546,6 +2314,37 @@ function renderVenn(container, parsed, palette, _isDark, onClickItem, exportDims
         dx /= mag;
         dy /= mag;
       }
+      const stubAt = (ux, uy) => {
+        const near = c.r + edgePad;
+        const far = near + stubLen;
+        return gapToTripleLeader(
+          c.x + ux * near,
+          c.y + uy * near,
+          c.x + ux * far,
+          c.y + uy * far
+        );
+      };
+      if (stubAt(dx, dy) < LEADER_CLEARANCE) {
+        let best = null;
+        for (const turn of [TRIPLE_DODGE, -TRIPLE_DODGE]) {
+          const cos = Math.cos(turn);
+          const sin = Math.sin(turn);
+          const ux = dx * cos - dy * sin;
+          const uy = dx * sin + dy * cos;
+          const exit = { x: c.x + ux * c.r, y: c.y + uy * c.r };
+          const blocked = circles.some(
+            (o, j) => j !== i && pointInCircle(exit, o)
+          );
+          if (blocked) continue;
+          const gap = stubAt(ux, uy);
+          if (!best || gap > best.gap || gap === best.gap && ux > best.x)
+            best = { x: ux, y: uy, gap };
+        }
+        if (best && best.gap >= LEADER_CLEARANCE) {
+          dx = best.x;
+          dy = best.y;
+        }
+      }
       const exitX = c.x + dx * c.r;
       const exitY = c.y + dy * c.r;
       const edgeX = exitX + dx * edgePad;
@@ -1943,8 +2742,6 @@ function renderWordCloud(container, parsed, palette, _isDark, onClickItem, expor
   const { svg, width, height, textColor, colors } = init;
   const idealWidth = Math.max(400, words.length * 30);
   const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(width, idealWidth);
-  const sTitleHeight = title ? ctx.aesthetic(40) : 0;
-  const cloudHeight = height - sTitleHeight;
   const sPadding = ctx.structural(2);
   svg.attr("preserveAspectRatio", "xMidYMid meet");
   if (ctx.isBelowFloor) {
@@ -1962,14 +2759,17 @@ function renderWordCloud(container, parsed, palette, _isDark, onClickItem, expor
     return sMinSize + Math.sqrt(t) * (sMaxSize - sMinSize);
   };
   const rotateFn = getRotateFn(cloudOptions.rotate);
-  renderChartTitle(
+  const titleExtra = renderChartTitle(
     svg,
     title,
     parsed.titleLineNumber,
     width,
     textColor,
-    onClickItem
+    onClickItem,
+    2
   );
+  const sTitleHeight = title ? ctx.aesthetic(40) + titleExtra : 0;
+  const cloudHeight = height - sTitleHeight;
   const g = svg.append("g").attr(
     "transform",
     `translate(${width / 2},${sTitleHeight + cloudHeight / 2})`
@@ -2008,8 +2808,6 @@ function renderWordCloudAsync(container, parsed, palette, _isDark, exportDims) {
       resolve();
       return;
     }
-    const titleHeight = title ? 40 : 0;
-    const cloudHeight = height - titleHeight;
     const textColor = palette.text;
     const bgColor = palette.bg;
     const colors = getSeriesColors(palette);
@@ -2024,7 +2822,17 @@ function renderWordCloudAsync(container, parsed, palette, _isDark, exportDims) {
     };
     const rotateFn = getRotateFn(cloudOptions.rotate);
     const svg = d3Selection3.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMid meet").style("background", bgColor);
-    renderChartTitle(svg, title, parsed.titleLineNumber, width, textColor);
+    const titleExtra = renderChartTitle(
+      svg,
+      title,
+      parsed.titleLineNumber,
+      width,
+      textColor,
+      void 0,
+      2
+    );
+    const titleHeight = title ? 40 + titleExtra : 0;
+    const cloudHeight = height - titleHeight;
     const g = svg.append("g").attr(
       "transform",
       `translate(${width / 2},${titleHeight + cloudHeight / 2})`
@@ -2084,8 +2892,8 @@ async function exportArc(ctx) {
 // src/block/export.ts
 async function exportBlock(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBlock: parseBlock2 } = await import("./parser-TUAEX6ML.js");
-  const { renderBlockForExport } = await import("./renderer-ISQJ2ELA.js");
+  const { parseBlock: parseBlock2 } = await import("./parser-JRKPOO2Z.js");
+  const { renderBlockForExport } = await import("./renderer-HIB6LZWZ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const blockParsed = parseBlock2(content, effectivePalette);
   if (blockParsed.error || blockParsed.top.rows.length === 0) return "";
@@ -2100,8 +2908,8 @@ async function exportBlock(ctx) {
 // src/body/export.ts
 async function exportBody(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBody: parseBody2 } = await import("./parser-PEZ7RN43.js");
-  const { renderBodyForExport } = await import("./renderer-AM7P4LN7.js");
+  const { parseBody: parseBody2 } = await import("./parser-QEMFMVF5.js");
+  const { renderBodyForExport } = await import("./renderer-A36NL2SS.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseBody2(content, effectivePalette);
   if (parsed.error) return "";
@@ -2120,7 +2928,7 @@ async function exportBody(ctx) {
 // src/boxes-and-lines/export.ts
 async function exportBoxesAndLines(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseBoxesAndLines: parseBoxesAndLines2 } = await import("./parser-ZRIZFDZY.js");
+  const { parseBoxesAndLines: parseBoxesAndLines2 } = await import("./parser-IZYIXDJX.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const blParsed = parseBoxesAndLines2(content, effectivePalette);
   if (blParsed.error || blParsed.nodes.length === 0) return "";
@@ -2131,9 +2939,17 @@ async function exportBoxesAndLines(ctx) {
       blHiddenTagValues.set(k, new Set(v));
     }
   }
-  const { renderBoxesAndLinesForExport } = await import("./renderer-2QPHDBZY.js");
-  const { layoutBoxesAndLines } = await import("./layout-TIBRMWHL.js");
-  const blLayout = await layoutBoxesAndLines(blParsed);
+  const { renderBoxesAndLinesForExport } = await import("./renderer-XMJ6XZGL.js");
+  const { layoutBoxesAndLines } = await import("./layout-6VY3DHYD.js");
+  const { collapseBoxesAndLines, unionCollapsedBLGroups } = await import("./collapse-HNTPLB2Q.js");
+  const cr = collapseBoxesAndLines(
+    blParsed,
+    unionCollapsedBLGroups(blParsed, viewState?.cg)
+  );
+  const blLayout = await layoutBoxesAndLines(cr.parsed, {
+    collapsedChildCounts: cr.collapsedChildCounts,
+    originalGroups: cr.originalGroups
+  });
   const PADDING = 20;
   const titleOffset = blParsed.title ? 40 : 0;
   const exportWidth = blLayout.width + PADDING * 2;
@@ -2142,7 +2958,7 @@ async function exportBoxesAndLines(ctx) {
   const blActiveTagGroup = ctxTagOverride(ctx);
   renderBoxesAndLinesForExport(
     container,
-    blParsed,
+    cr.parsed,
     blLayout,
     effectivePalette,
     ctx.isDark,
@@ -2163,8 +2979,8 @@ async function exportBoxesAndLines(ctx) {
 // src/bracket/export.ts
 async function exportBracket(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseBracket: parseBracket2 } = await import("./parser-RTWPFKXG.js");
-  const { renderBracketForExport, bracketExportDimensions } = await import("./renderer-2LYX6NHN.js");
+  const { parseBracket: parseBracket2 } = await import("./parser-GMCXCJSP.js");
+  const { renderBracketForExport, bracketExportDimensions } = await import("./renderer-KOPJ76GS.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseBracket2(content, effectivePalette);
   if (parsed.error) return "";
@@ -2180,14 +2996,14 @@ async function exportBracket(ctx) {
 // src/c4/export.ts
 async function exportC4(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseC4: parseC42 } = await import("./parser-4Y6PODW6.js");
+  const { parseC4: parseC42 } = await import("./parser-WKEYS7N3.js");
   const {
     layoutC4Context,
     layoutC4Containers,
     layoutC4Components,
     layoutC4Deployment
-  } = await import("./layout-JTIRCKAW.js");
-  const { renderC4Context, renderC4Containers } = await import("./renderer-QTPWRRJ7.js");
+  } = await import("./layout-R6ULGQJK.js");
+  const { renderC4Context, renderC4Containers } = await import("./renderer-UIHCYXBY.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const c4Parsed = parseC42(content, effectivePalette);
   if (c4Parsed.error || c4Parsed.elements.length === 0) return "";
@@ -2223,9 +3039,9 @@ async function exportC4(ctx) {
 // src/class/export.ts
 async function exportClass(ctx) {
   const { content, theme, palette, exportMode } = ctx;
-  const { parseClassDiagram: parseClassDiagram2 } = await import("./parser-MA7L3XND.js");
-  const { layoutClassDiagram } = await import("./layout-5SZ5A64I.js");
-  const { renderClassDiagram } = await import("./renderer-P3WR7TKD.js");
+  const { parseClassDiagram: parseClassDiagram2 } = await import("./parser-RSWZGQA7.js");
+  const { layoutClassDiagram } = await import("./layout-7C2QZCEZ.js");
+  const { renderClassDiagram } = await import("./renderer-4PKYVOYL.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const classParsed = parseClassDiagram2(content, effectivePalette);
   if (classParsed.error || classParsed.classes.length === 0) return "";
@@ -2252,7 +3068,7 @@ async function exportClass(ctx) {
 // src/clock/export.ts
 async function exportClock(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseClock: parseClock2 } = await import("./parser-K2DI26SC.js");
+  const { parseClock: parseClock2 } = await import("./parser-SGX2PVR5.js");
   const { renderClockForExport } = await import("./renderer-DDWDCM2K.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseClock2(content, effectivePalette);
@@ -2268,7 +3084,7 @@ async function exportClock(ctx) {
 // src/countdown/export.ts
 async function exportCountdown(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseCountdown: parseCountdown2 } = await import("./parser-KJPPUN4D.js");
+  const { parseCountdown: parseCountdown2 } = await import("./parser-5KVFS4RN.js");
   const { renderCountdownForExport } = await import("./renderer-3NLDX7DQ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseCountdown2(content, effectivePalette);
@@ -2284,8 +3100,8 @@ async function exportCountdown(ctx) {
 // src/cycle/export.ts
 async function exportCycle(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseCycle: parseCycle2 } = await import("./parser-RCIEKN7Y.js");
-  const { renderCycleForExport } = await import("./renderer-7OGGV327.js");
+  const { parseCycle: parseCycle2 } = await import("./parser-P375HO7Q.js");
+  const { renderCycleForExport } = await import("./renderer-FAFSRFGR.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const cycleParsed = parseCycle2(content);
   if (cycleParsed.error || cycleParsed.nodes.length === 0) return "";
@@ -2305,9 +3121,9 @@ async function exportCycle(ctx) {
 // src/er/export.ts
 async function exportEr(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseERDiagram: parseERDiagram2 } = await import("./parser-BTSTKY5G.js");
-  const { layoutERDiagram } = await import("./layout-YBMT74MG.js");
-  const { renderERDiagram } = await import("./renderer-4VGO27EE.js");
+  const { parseERDiagram: parseERDiagram2 } = await import("./parser-IU6425JW.js");
+  const { layoutERDiagram } = await import("./layout-G3RVKEC4.js");
+  const { renderERDiagram } = await import("./renderer-COV2DXTM.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const erParsed = parseERDiagram2(content, effectivePalette);
   if (erParsed.error || erParsed.tables.length === 0) return "";
@@ -2341,8 +3157,8 @@ async function exportEr(ctx) {
 // src/event-line/export.ts
 async function exportEventLine(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseEventLine: parseEventLine2 } = await import("./parser-YG625J5H.js");
-  const { renderEventLineForExport } = await import("./renderer-Y47EM337.js");
+  const { parseEventLine: parseEventLine2 } = await import("./parser-MAGFK6OK.js");
+  const { renderEventLineForExport } = await import("./renderer-CNDB4JTZ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseEventLine2(content, effectivePalette);
   if (parsed.error || parsed.events.length === 0) return "";
@@ -2362,9 +3178,9 @@ async function exportEventLine(ctx) {
 // src/family/export.ts
 async function exportFamily(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseFamily: parseFamily2 } = await import("./parser-EAQPZX2B.js");
-  const { layoutFamily } = await import("./layout-3TSVAGWH.js");
-  const { renderFamilyForExport } = await import("./renderer-XCLARXCK.js");
+  const { parseFamily: parseFamily2 } = await import("./parser-MUHFEM4G.js");
+  const { layoutFamily } = await import("./layout-SPPS225I.js");
+  const { renderFamilyForExport } = await import("./renderer-6O5SV5YE.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseFamily2(content, effectivePalette);
   if (parsed.error || parsed.persons.size === 0) return "";
@@ -2396,9 +3212,9 @@ async function exportFamily(ctx) {
 // src/gantt/export.ts
 async function exportGantt(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseGantt: parseGantt2 } = await import("./parser-A3AN76RQ.js");
-  const { calculateSchedule } = await import("./calculator-BNH3GSJE.js");
-  const { renderGantt } = await import("./renderer-JYHA6R2D.js");
+  const { parseGantt: parseGantt2 } = await import("./parser-DRFEX6OX.js");
+  const { calculateSchedule } = await import("./calculator-CIGGTURF.js");
+  const { renderGantt } = await import("./renderer-E5E3OJ42.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const ganttParsed = parseGantt2(content, effectivePalette);
   const resolved = calculateSchedule(ganttParsed);
@@ -2441,8 +3257,8 @@ async function exportGantt(ctx) {
 // src/goal/export.ts
 async function exportGoal(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseGoal: parseGoal2 } = await import("./parser-3QIFY5IN.js");
-  const { renderGoalForExport } = await import("./renderer-HX6ICPDX.js");
+  const { parseGoal: parseGoal2 } = await import("./parser-UMNBPXG2.js");
+  const { renderGoalForExport } = await import("./renderer-MYKL6VG6.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseGoal2(content, effectivePalette);
   if (parsed.error) return "";
@@ -2457,9 +3273,9 @@ async function exportGoal(ctx) {
 // src/graph/export.ts
 async function exportFlowchart(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseFlowchart: parseFlowchart2 } = await import("./flowchart-parser-J3VWIFWB.js");
-  const { layoutGraph } = await import("./layout-EWXHEXNS.js");
-  const { renderFlowchart } = await import("./flowchart-renderer-FECH5KK5.js");
+  const { parseFlowchart: parseFlowchart2 } = await import("./flowchart-parser-UI5VZNGJ.js");
+  const { layoutGraph } = await import("./layout-WBH5IHYK.js");
+  const { renderFlowchart } = await import("./flowchart-renderer-IYWPKPCF.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const fcParsed = parseFlowchart2(content, effectivePalette);
   if (fcParsed.error || fcParsed.nodes.length === 0) return "";
@@ -2478,9 +3294,9 @@ async function exportFlowchart(ctx) {
 }
 async function exportState(ctx) {
   const { content, theme, palette, viewState } = ctx;
-  const { parseState: parseState2 } = await import("./state-parser-PMNHLHLE.js");
-  const { layoutGraph } = await import("./layout-EWXHEXNS.js");
-  const { renderState } = await import("./state-renderer-JQ5DS66J.js");
+  const { parseState: parseState2 } = await import("./state-parser-2PQRH5JE.js");
+  const { layoutGraph } = await import("./layout-WBH5IHYK.js");
+  const { renderState } = await import("./state-renderer-YP6HWLJR.js");
   const { collapseStateGroups } = await import("./state-collapse-SE2G4K4I.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const stateParsed = parseState2(content, effectivePalette);
@@ -2519,10 +3335,10 @@ async function exportState(ctx) {
 // src/infra/export.ts
 async function exportInfra(ctx) {
   const { content, theme, palette, viewState } = ctx;
-  const { parseInfra: parseInfra2 } = await import("./parser-F7NDRPMA.js");
+  const { parseInfra: parseInfra2 } = await import("./parser-WE4VSBBY.js");
   const { computeInfra } = await import("./compute-II4G44IK.js");
-  const { layoutInfra } = await import("./layout-2WESJYRE.js");
-  const { renderInfra, computeInfraLegendGroups } = await import("./renderer-UTEEJDGB.js");
+  const { layoutInfra } = await import("./layout-7E7BNOGO.js");
+  const { renderInfra, computeInfraLegendGroups } = await import("./renderer-JLOKFKOZ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const infraParsed = parseInfra2(content);
   if (infraParsed.error || infraParsed.nodes.length === 0) return "";
@@ -2570,16 +3386,22 @@ async function exportInfra(ctx) {
 
 // src/journey-map/export.ts
 async function exportJourneyMap(ctx) {
-  const { content, theme, palette, exportMode } = ctx;
-  const { parseJourneyMap: parseJourneyMap2 } = await import("./parser-NL73FSFI.js");
-  const { renderJourneyMap } = await import("./renderer-IVHD7ENY.js");
-  const { layoutJourneyMap } = await import("./layout-HFBK5UEG.js");
+  const { content, theme, palette, exportMode, viewState } = ctx;
+  const { parseJourneyMap: parseJourneyMap2 } = await import("./parser-IHFHPFL7.js");
+  const { renderJourneyMap } = await import("./renderer-66SCERH7.js");
+  const { layoutJourneyMap } = await import("./layout-ROI5KVSO.js");
+  const { collapsedJourneyPhasesFromSource } = await import("./collapse-GOWNCVHZ.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const jmParsed = parseJourneyMap2(content, effectivePalette);
   if (jmParsed.error || jmParsed.phases.length === 0 && jmParsed.steps.length === 0)
     return "";
+  const collapsedPhases = collapsedJourneyPhasesFromSource(
+    jmParsed,
+    viewState?.cg
+  );
   const jmLayout = layoutJourneyMap(jmParsed, effectivePalette, {
-    isDark: ctx.isDark
+    isDark: ctx.isDark,
+    collapsedPhases
   });
   const container = createExportContainer(
     jmLayout.totalWidth,
@@ -2587,7 +3409,8 @@ async function exportJourneyMap(ctx) {
   );
   renderJourneyMap(container, jmParsed, effectivePalette, ctx.isDark, {
     exportDims: { width: jmLayout.totalWidth, height: jmLayout.totalHeight },
-    exportMode
+    exportMode,
+    collapsedPhases
   });
   return finalizeSvgExport(container, theme, effectivePalette);
 }
@@ -2595,8 +3418,8 @@ async function exportJourneyMap(ctx) {
 // src/kanban/export.ts
 async function exportKanban(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseKanban: parseKanban2 } = await import("./parser-KLCSFQ3J.js");
-  const { renderKanban } = await import("./renderer-KJ3V5BYP.js");
+  const { parseKanban: parseKanban2 } = await import("./parser-WPXUUNA2.js");
+  const { renderKanban } = await import("./renderer-ITJ67HXO.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const kanbanParsed = parseKanban2(content, effectivePalette);
   if (kanbanParsed.error || kanbanParsed.columns.length === 0) return "";
@@ -2629,8 +3452,8 @@ async function exportKanban(ctx) {
 // src/live-link/export.ts
 async function exportLiveLink(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseLiveLink: parseLiveLink2 } = await import("./parser-GMQJISZ6.js");
-  const { renderLiveLinkCard } = await import("./renderer-ZV6KCLCL.js");
+  const { parseLiveLink: parseLiveLink2 } = await import("./parser-PYY5BRLQ.js");
+  const { renderLiveLinkCard } = await import("./renderer-6IAXRZLK.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   return renderLiveLinkCard(parseLiveLink2(content), effectivePalette, theme);
 }
@@ -2647,10 +3470,10 @@ async function resolveMapDataSource(source) {
 }
 async function exportMap(ctx) {
   const { content, theme, palette, options } = ctx;
-  const { parseMap: parseMap2 } = await import("./parser-EFF22GYO.js");
+  const { parseMap: parseMap2 } = await import("./parser-CFAYEWLF.js");
   const { resolveMap } = await import("./resolver-33K6MBCT.js");
-  const { renderMapForExport } = await import("./renderer-BXD5KVSR.js");
-  const { mapExportDimensions } = await import("./dimensions-DS6FWLRY.js");
+  const { renderMapForExport } = await import("./renderer-S6L3JR6C.js");
+  const { mapExportDimensions } = await import("./dimensions-KXAI7U2B.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const mapParsed = parseMap2(content, effectivePalette);
   const { data: mapData, reason } = await resolveMapDataSource(
@@ -2685,10 +3508,10 @@ async function exportMap(ctx) {
 // src/mindmap/export.ts
 async function exportMindmap(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseMindmap: parseMindmap2 } = await import("./parser-KKF6Y5MM.js");
-  const { layoutMindmap } = await import("./layout-RH3N46HP.js");
-  const { collapseMindmapTree } = await import("./collapse-BSPH3BFM.js");
-  const { renderMindmap } = await import("./renderer-XDX6S7OV.js");
+  const { parseMindmap: parseMindmap2 } = await import("./parser-SJUEFKNM.js");
+  const { layoutMindmap } = await import("./layout-FJDBY3WG.js");
+  const { collapseMindmapTree } = await import("./collapse-6X5S2S3G.js");
+  const { renderMindmap } = await import("./renderer-TCTZZ5Y6.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
   const mmParsed = parseMindmap2(content, effectivePalette);
@@ -2740,10 +3563,10 @@ async function exportMindmap(ctx) {
 // src/org/export.ts
 async function exportOrg(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseOrg: parseOrg2, findOrgNodeIdByName } = await import("./parser-BJ7RJNUM.js");
-  const { layoutOrg } = await import("./layout-MXHR3P35.js");
+  const { parseOrg: parseOrg2, findOrgNodeIdByName } = await import("./parser-E4B7HJT2.js");
+  const { layoutOrg } = await import("./layout-WTHBGTH2.js");
   const { collapseOrgTree, focusOrgTree, unionCollapsedOrgNodes } = await import("./collapse-VNYYXMUI.js");
-  const { renderOrg, ancestorTrailReserve } = await import("./renderer-6BDK47V6.js");
+  const { renderOrg, ancestorTrailReserve } = await import("./renderer-DXCATVLO.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
   const orgParsed = parseOrg2(content, effectivePalette);
@@ -2803,59 +3626,11 @@ async function exportOrg(ctx) {
   return finalizeSvgExport(container, theme, effectivePalette);
 }
 
-// src/pert/export.ts
-async function exportPert(ctx) {
-  const { content, theme, palette, viewState } = ctx;
-  const { parsePert: parsePert2 } = await import("./parser-2IKPQVKX.js");
-  const { analyzePert } = await import("./analyzer-G7PGOT3V.js");
-  const { layoutPert } = await import("./layout-KV27UW25.js");
-  const { renderPert, measurePertAnalysisBlock } = await import("./renderer-MWZC7TMD.js");
-  const effectivePalette = await resolveExportPalette(theme, palette);
-  const pertParsed = parsePert2(content, { palette: effectivePalette });
-  if (pertParsed.error || pertParsed.activities.length === 0) return "";
-  const pertResolved = analyzePert(pertParsed);
-  const pertLayout = layoutPert(pertResolved);
-  const hasTitle = !!pertParsed.title && !pertParsed.options.noTitle;
-  const hasSubtitle = pertResolved.projectSubtitle !== null;
-  const titleHeight = hasTitle ? 80 : hasSubtitle ? 50 : 0;
-  const PERT_PADDING = 20;
-  const analysisOn = viewState?.an ?? !pertParsed.options.noAnalysis;
-  const fieldLabelsOn = viewState?.fl === true;
-  const exportW = pertLayout.width + PERT_PADDING * 2;
-  const analysisMeasured = measurePertAnalysisBlock(
-    pertResolved,
-    exportW - 2 * PERT_PADDING,
-    {
-      showTornado: analysisOn,
-      showScurve: analysisOn,
-      showFieldLegend: fieldLabelsOn
-    }
-  );
-  const exportH = pertLayout.height + PERT_PADDING * 2 + titleHeight + analysisMeasured.height;
-  const container = createExportContainer(exportW, exportH);
-  renderPert(
-    container,
-    pertResolved,
-    pertLayout,
-    effectivePalette,
-    ctx.isDark,
-    {
-      title: hasTitle ? pertParsed.title : null,
-      subtitle: pertResolved.projectSubtitle,
-      exportDims: { width: exportW, height: exportH },
-      showTornado: analysisOn,
-      showScurve: analysisOn,
-      showFieldLegend: fieldLabelsOn
-    }
-  );
-  return finalizeSvgExport(container, theme, effectivePalette);
-}
-
 // src/pyramid/export.ts
 async function exportPyramid(ctx) {
   const { content, theme, palette } = ctx;
-  const { parsePyramid: parsePyramid2 } = await import("./parser-NUU3DVW4.js");
-  const { renderPyramidForExport } = await import("./renderer-IXBOT6DU.js");
+  const { parsePyramid: parsePyramid2 } = await import("./parser-3PMYAVFL.js");
+  const { renderPyramidForExport } = await import("./renderer-7OXMSF4R.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const pyramidParsed = parsePyramid2(content);
   if (pyramidParsed.error || pyramidParsed.layers.length === 0) return "";
@@ -2890,16 +3665,43 @@ async function exportQuadrant(ctx) {
 
 // src/raci/export.ts
 async function exportRaci(ctx) {
-  const { content, theme, palette } = ctx;
-  const { parseRaci: parseRaci2 } = await import("./parser-GDLKUBTO.js");
-  const { renderRaciForExport } = await import("./renderer-W4MUMXJE.js");
+  const { content, theme, palette, viewState } = ctx;
+  const { parseRaci: parseRaci2 } = await import("./parser-QIPDBT5M.js");
+  const { renderRaciForExport } = await import("./renderer-BXVTYE27.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const raciParsed = parseRaci2(content, effectivePalette);
   if (raciParsed.error) return "";
   const container = createExportContainer(ctx.width, ctx.height);
-  renderRaciForExport(container, raciParsed, effectivePalette, ctx.isDark, {
-    width: ctx.width,
-    height: ctx.height
+  renderRaciForExport(
+    container,
+    raciParsed,
+    effectivePalette,
+    ctx.isDark,
+    { width: ctx.width, height: ctx.height },
+    viewState?.cs
+  );
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+
+// src/swot/export.ts
+async function exportSwot(ctx) {
+  const { content, theme, palette, exportMode } = ctx;
+  const { parseSwot: parseSwot2 } = await import("./parser-LDVVBP7S.js");
+  const { renderSwot } = await import("./renderer-CC6O6GQK.js");
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const parsed = parseSwot2(content, effectivePalette);
+  if (parsed.error) return "";
+  const container = document.createElement("div");
+  container.style.position = "absolute";
+  container.style.left = "-9999px";
+  document.body.appendChild(container);
+  renderSwot(container, parsed, effectivePalette, ctx.isDark, {
+    activeTagGroup: resolveActiveTagGroup(
+      parsed.tagGroups,
+      parsed.options["active-tag"],
+      ctxTagOverride(ctx)
+    ),
+    exportMode
   });
   return finalizeSvgExport(container, theme, effectivePalette);
 }
@@ -2907,8 +3709,8 @@ async function exportRaci(ctx) {
 // src/ring/export.ts
 async function exportRing(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseRing: parseRing2 } = await import("./parser-KMKVFET2.js");
-  const { renderRingForExport } = await import("./renderer-RUSQJFFC.js");
+  const { parseRing: parseRing2 } = await import("./parser-KI2XYB2R.js");
+  const { renderRingForExport } = await import("./renderer-F3JYZERE.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const ringParsed = parseRing2(content);
   if (ringParsed.error || ringParsed.layers.length === 0) return "";
@@ -2935,12 +3737,21 @@ async function exportVisualization(ctx) {
   const effectivePalette = await resolveExportPalette(theme, palette);
   const isDark = ctx.isDark;
   const container = createExportContainer(ctx.width, ctx.height);
-  const { parseSequenceDgmo: parseSequenceDgmo2 } = await import("./parser-BT4NI6JY.js");
-  const { renderSequenceDiagram } = await import("./renderer-ACQQ2JXA.js");
+  const { parseSequenceDgmo: parseSequenceDgmo2 } = await import("./parser-RNBDDEGL.js");
+  const { renderSequenceDiagram } = await import("./renderer-ASPBBACI.js");
   const seqParsed = parseSequenceDgmo2(content, effectivePalette);
   if (seqParsed.error || seqParsed.participants.length === 0) return "";
-  const collapsedSections = viewState?.cs ? new Set(viewState.cs) : void 0;
+  const {
+    unionCollapsedSequenceNotes,
+    collapsedSequenceSectionLinesFromSource
+  } = await import("./collapse-6IGH2B24.js");
+  const collapsedSections = collapsedSequenceSectionLinesFromSource(seqParsed);
+  for (const line2 of viewState?.cs ?? []) collapsedSections.add(line2);
   const collapsedGroups = viewState?.cg ? new Set(viewState.cg.map(Number).filter((n) => Number.isFinite(n))) : void 0;
+  const collapsedNotes = unionCollapsedSequenceNotes(
+    seqParsed,
+    viewState?.cg?.map(Number).filter((n) => Number.isFinite(n))
+  );
   const seqActiveTagGroup = ctxTagOverride(ctx);
   renderSequenceDiagram(
     container,
@@ -2953,8 +3764,9 @@ async function exportVisualization(ctx) {
       ...seqActiveTagGroup !== void 0 && {
         activeTagGroup: seqActiveTagGroup
       },
-      ...collapsedSections !== void 0 && { collapsedSections },
-      ...collapsedGroups !== void 0 && { collapsedGroups }
+      ...collapsedSections.size > 0 && { collapsedSections },
+      ...collapsedGroups !== void 0 && { collapsedGroups },
+      collapsedNotes
     }
   );
   return finalizeSvgExport(container, theme, effectivePalette);
@@ -2963,15 +3775,18 @@ async function exportVisualization(ctx) {
 // src/sitemap/export.ts
 async function exportSitemap(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseSitemap: parseSitemap2 } = await import("./parser-6TDWUKM5.js");
-  const { layoutSitemap } = await import("./layout-ND26WVX2.js");
-  const { collapseSitemapTree } = await import("./collapse-TCVK3RPO.js");
-  const { renderSitemap } = await import("./renderer-UGW4N2W5.js");
+  const { parseSitemap: parseSitemap2 } = await import("./parser-BA43YPIQ.js");
+  const { layoutSitemap } = await import("./layout-ZCCABSV7.js");
+  const { collapseSitemapTree, unionCollapsedSitemapNodes } = await import("./collapse-NUM7DPJA.js");
+  const { renderSitemap } = await import("./renderer-HLDRRFZB.js");
   const isDark = ctx.isDark;
   const effectivePalette = await resolveExportPalette(theme, palette);
   const sitemapParsed = parseSitemap2(content, effectivePalette);
   if (sitemapParsed.error || sitemapParsed.roots.length === 0) return "";
-  const collapsedNodes = viewState?.cg ? new Set(viewState.cg) : void 0;
+  const collapsedNodes = unionCollapsedSitemapNodes(
+    sitemapParsed,
+    viewState?.cg
+  );
   const activeTagGroup = resolveActiveTagGroup(
     sitemapParsed.tagGroups,
     sitemapParsed.options["active-tag"],
@@ -2981,7 +3796,7 @@ async function exportSitemap(ctx) {
     sitemapParsed.options["hide"],
     viewState?.ha
   );
-  const { parsed: effectiveParsed, hiddenCounts } = collapsedNodes && collapsedNodes.size > 0 ? collapseSitemapTree(sitemapParsed, collapsedNodes) : { parsed: sitemapParsed, hiddenCounts: /* @__PURE__ */ new Map() };
+  const { parsed: effectiveParsed, hiddenCounts } = collapsedNodes.size > 0 ? collapseSitemapTree(sitemapParsed, collapsedNodes) : { parsed: sitemapParsed, hiddenCounts: /* @__PURE__ */ new Map() };
   const sitemapLayout = layoutSitemap(
     effectiveParsed,
     hiddenCounts.size > 0 ? hiddenCounts : void 0,
@@ -2994,7 +3809,7 @@ async function exportSitemap(ctx) {
   const {
     LEGEND_HEIGHT: SITEMAP_LEGEND_HEIGHT,
     LEGEND_GROUP_GAP: SITEMAP_LEGEND_GROUP_GAP
-  } = await import("./legend-constants-55MFBXYF.js");
+  } = await import("./legend-constants-KF3MKWL2.js");
   const suppressedLegendBand = sitemapLayout.legend.length > 0 && effectiveParsed.options["no-legend"] === "on" ? SITEMAP_LEGEND_HEIGHT + SITEMAP_LEGEND_GROUP_GAP : 0;
   const exportWidth = sitemapLayout.width + PADDING * 2;
   const exportHeight = sitemapLayout.height + PADDING * 2 + titleOffset - suppressedLegendBand;
@@ -3014,42 +3829,6 @@ async function exportSitemap(ctx) {
   return finalizeSvgExport(container, theme, effectivePalette);
 }
 
-// src/sketch/export.ts
-async function exportSketch(ctx) {
-  const { content, theme, viewState, exportMode } = ctx;
-  const { parseSketch: parseSketch2 } = await import("./parser-YHDGKPZI.js");
-  const effectivePalette = await resolveExportPalette(theme, ctx.palette);
-  const parsed = parseSketch2(content, effectivePalette);
-  if (parsed.error || parsed.nodes.length === 0 && parsed.boxes.length === 0) {
-    return "";
-  }
-  const { layoutSketch } = await import("./layout-D4L44NRG.js");
-  const { renderSketchForExport } = await import("./renderer-WPN2SXGT.js");
-  const collapsedBoxes = viewState?.cg ? new Set(viewState.cg) : void 0;
-  const skLayout = layoutSketch(parsed, {
-    ...collapsedBoxes !== void 0 && { collapsedBoxes }
-  });
-  const PADDING = 20;
-  const titleOffset = parsed.title ? 40 : 0;
-  const exportWidth = skLayout.width + PADDING * 2;
-  const exportHeight = skLayout.height + PADDING * 2 + titleOffset;
-  const container = createExportContainer(exportWidth, exportHeight);
-  const skTagOverride = ctxTagOverride(ctx);
-  renderSketchForExport(
-    container,
-    parsed,
-    skLayout,
-    effectivePalette,
-    ctx.isDark,
-    {
-      ...skTagOverride !== void 0 && { activeTagGroup: skTagOverride },
-      ...exportMode !== void 0 && { exportMode },
-      ...viewState?.hd !== void 0 && { hideDescriptions: viewState.hd }
-    }
-  );
-  return finalizeSvgExport(container, theme, effectivePalette);
-}
-
 // src/slope/export.ts
 async function exportSlope(ctx) {
   const { content, theme, palette } = ctx;
@@ -3071,9 +3850,9 @@ async function exportSlope(ctx) {
 // src/swimlane/export.ts
 async function exportSwimlane(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseSwimlane: parseSwimlane2 } = await import("./parser-H5OODY5N.js");
-  const { layoutSwimlane } = await import("./layout-VDCJOZSH.js");
-  const { renderSwimlaneForExport } = await import("./renderer-DAZWHNLI.js");
+  const { parseSwimlane: parseSwimlane2 } = await import("./parser-DWVBRBB2.js");
+  const { layoutSwimlane } = await import("./layout-BSK374N6.js");
+  const { renderSwimlaneForExport } = await import("./renderer-E7LC7HCU.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const swimParsed = parseSwimlane2(content, effectivePalette);
   if (swimParsed.error || swimParsed.nodes.length === 0) return "";
@@ -3105,8 +3884,8 @@ async function exportSwimlane(ctx) {
 // src/tech-radar/export.ts
 async function exportTechRadar(ctx) {
   const { content, theme, palette, viewState, exportMode } = ctx;
-  const { parseTechRadar: parseTechRadar2 } = await import("./parser-3LT3ZUUC.js");
-  const { renderTechRadarForExport } = await import("./renderer-TINHO2IO.js");
+  const { parseTechRadar: parseTechRadar2 } = await import("./parser-YZ3J542U.js");
+  const { renderTechRadarForExport } = await import("./renderer-ZTHXOBXW.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const radarParsed = parseTechRadar2(content);
   if (radarParsed.error || radarParsed.quadrants.length === 0) return "";
@@ -3157,14 +3936,14 @@ async function exportTimeline(ctx) {
 // src/treemap/export.ts
 async function exportTreemap(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseTreemap: parseTreemap2 } = await import("./parser-LTRQASGB.js");
+  const { parseTreemap: parseTreemap2 } = await import("./parser-XP3RCOTN.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const treemapParsed = parseTreemap2(content, effectivePalette);
   if (treemapParsed.error || treemapParsed.roots.length === 0) return "";
   const container = createExportContainer(ctx.width, ctx.height);
   const dims = { width: ctx.width, height: ctx.height };
   if (treemapParsed.options.radial) {
-    const { renderTreemapRadialForExport } = await import("./renderer-radial-WFUX3Z3C.js");
+    const { renderTreemapRadialForExport } = await import("./renderer-radial-FC25BDCZ.js");
     renderTreemapRadialForExport(
       container,
       treemapParsed,
@@ -3173,7 +3952,7 @@ async function exportTreemap(ctx) {
       dims
     );
   } else {
-    const { renderTreemapForExport } = await import("./renderer-O6RP52CQ.js");
+    const { renderTreemapForExport } = await import("./renderer-INQMQPNN.js");
     renderTreemapForExport(
       container,
       treemapParsed,
@@ -3199,8 +3978,8 @@ async function exportVenn(ctx) {
 // src/version-control/export.ts
 async function exportVersionControl(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseVersionControl: parseVersionControl2 } = await import("./parser-5UZV32ZI.js");
-  const { renderVersionControlForExport } = await import("./renderer-NOYLNVTI.js");
+  const { parseVersionControl: parseVersionControl2 } = await import("./parser-FWQY3HJX.js");
+  const { renderVersionControlForExport } = await import("./renderer-SYWVZ4CY.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const parsed = parseVersionControl2(content, effectivePalette);
   if (parsed.error || parsed.nodes.length === 0) return "";
@@ -3221,11 +4000,11 @@ async function exportVersionControl(ctx) {
 // src/whiteboard/export.ts
 async function exportWhiteboard(ctx) {
   const { content, theme } = ctx;
-  const { parseWhiteboard: parseWhiteboard2 } = await import("./parser-AR2GON37.js");
+  const { parseWhiteboard: parseWhiteboard2 } = await import("./parser-MH5BDN7X.js");
   const effectivePalette = await resolveExportPalette(theme, ctx.palette);
   const parsed = parseWhiteboard2(content, effectivePalette);
   if (parsed.error || parsed.elements.length === 0) return "";
-  const { renderWhiteboard } = await import("./renderer-IGSHD3OT.js");
+  const { renderWhiteboard } = await import("./renderer-2V5NVI3V.js");
   const container = createExportContainer(1, 1);
   const resolveImage = ctx.options?.resolveImage;
   const showNotes = ctx.options?.showNotes;
@@ -3239,9 +4018,9 @@ async function exportWhiteboard(ctx) {
 // src/wireframe/export.ts
 async function exportWireframe(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseWireframe: parseWireframe2 } = await import("./parser-4TBSWULQ.js");
-  const { layoutWireframe } = await import("./layout-HF3PMI4H.js");
-  const { renderWireframe } = await import("./renderer-36446HSH.js");
+  const { parseWireframe: parseWireframe2 } = await import("./parser-JQGUTDSX.js");
+  const { layoutWireframe } = await import("./layout-VTGOYGRC.js");
+  const { renderWireframe } = await import("./renderer-WIBVOPRC.js");
   const effectivePalette = await resolveExportPalette(theme, palette);
   const wireframeParsed = parseWireframe2(content);
   if (wireframeParsed.error || wireframeParsed.roots.length === 0 && wireframeParsed.modals.length === 0)
@@ -3288,7 +4067,6 @@ var DIAGRAM_EXPORT_HANDLERS = {
   class: exportClass,
   er: exportEr,
   "boxes-and-lines": exportBoxesAndLines,
-  sketch: exportSketch,
   whiteboard: exportWhiteboard,
   swimlane: exportSwimlane,
   family: exportFamily,
@@ -3314,6 +4092,7 @@ var DIAGRAM_EXPORT_HANDLERS = {
   clock: exportClock,
   bracket: exportBracket,
   raci: exportRaci,
+  swot: exportSwot,
   body: exportBody,
   "live-link": exportLiveLink,
   // D3 visualizations — own handler per type (Story 109.2). Only `sequence`
@@ -3344,18 +4123,21 @@ function resolveArcChordOverride(content, detectedType, palette) {
 }
 async function renderForExport(content, theme, palette, viewState, options) {
   const exportMode = options?.exportMode ?? false;
-  const { parseDgmoChartType } = await import("./dgmo-router-6YLKM6WU.js");
+  const { parseDgmoChartType } = await import("./dgmo-router-RSYWR5IS.js");
   const detectedTypeRaw = parseDgmoChartType(content);
   const override = resolveArcChordOverride(content, detectedTypeRaw, palette);
   const renderContent = override?.content ?? content;
   const detectedType = override?.type ?? detectedTypeRaw;
   if (detectedType !== null) {
-    const { supportsD3DataChart, renderDataChartD3: renderDataChartD32 } = await import("./charts-d3-SZV2SFTM.js");
+    const { supportsD3DataChart, renderDataChartD3: renderDataChartD32 } = await import("./charts-d3-INWEGMSD.js");
     if (supportsD3DataChart(detectedType)) {
-      return renderDataChartD32(renderContent, theme, palette, {
-        ...options?.width !== void 0 && { width: options.width },
-        ...options?.height !== void 0 && { height: options.height }
-      });
+      return fitSvgToContent(
+        await renderDataChartD32(renderContent, theme, palette, {
+          ...options?.width !== void 0 && { width: options.width },
+          ...options?.height !== void 0 && { height: options.height }
+        }),
+        exportFitRequest(options)
+      );
     }
   }
   const ctx = {
@@ -3376,7 +4158,16 @@ async function renderForExport(content, theme, palette, viewState, options) {
     height: options?.height && options.height > 0 ? Math.round(options.height) : EXPORT_HEIGHT
   };
   const handler = detectedType !== null ? DIAGRAM_EXPORT_HANDLERS[detectedType] : void 0;
-  return (handler ?? exportVisualization)(ctx);
+  return fitSvgToContent(
+    await (handler ?? exportVisualization)(ctx),
+    exportFitRequest(options)
+  );
+}
+function exportFitRequest(options) {
+  return {
+    ...options?.width !== void 0 && { width: options.width },
+    ...options?.height !== void 0 && { height: options.height }
+  };
 }
 
 // src/utils/hover-styles.ts
@@ -3517,6 +4308,7 @@ function buildHoverCss(spec, derived = {}, emphasisOverride) {
     }
   }
   const parts = [...base];
+  if (spec.extraCross) cross.push(...spec.extraCross(dimOpacity));
   if (cross.length) parts.push(`@media (hover:hover){${cross.join("")}}`);
   return parts.join("");
 }
@@ -3720,17 +4512,6 @@ var HOVER_SPECS = {
     emphasis: "dim",
     legend: true
   },
-  sketch: {
-    markSelector: ".sk-node",
-    strategy: "connection",
-    hoverSelector: ".sk-node",
-    hoverAttr: "data-node-id",
-    edgeSelector: ".sk-edge-group",
-    fromAttr: "data-from",
-    toAttr: "data-to",
-    legend: true,
-    emphasis: "dim"
-  },
   infra: {
     markSelector: ".infra-node",
     strategy: "connection",
@@ -3845,6 +4626,24 @@ var HOVER_SPECS = {
     legend: true,
     legendMarkSelector: ".kanban-card"
   },
+  // swot: as kanban — hovering anywhere in a panel dims the other three, and the
+  // tag legend pairs on the items, which carry `data-tag-<slug>`.
+  swot: {
+    markSelector: ".swot-panel",
+    strategy: "structural",
+    groupSelector: ".swot-panel",
+    emphasis: "dim",
+    selfEmphasis: false,
+    legend: true,
+    legendMarkSelector: ".swot-item",
+    // An axis header keeps the two panels it heads (#1742): HELPFUL → S and
+    // O, INTERNAL → S and W. The other two panels and headers dim.
+    extraCross: (dim) => ["col", "row"].flatMap(
+      (axis) => [0, 1].map(
+        (i) => `svg:has(.swot-axis[data-swot-axis="${axis}-${i}"]:hover) :is(.swot-panel:not([data-swot-${axis}="${i}"]),.swot-axis:not([data-swot-axis="${axis}-${i}"])){opacity:${dim}}`
+      )
+    )
+  },
   // line: each series is a `g.dgmo-series` wrapping its line + data dots + an
   // invisible fat hit corridor (`.dgmo-series-hit`, renderer-baked) — without
   // the corridor only the 2.5px stroke and 4px dots were hittable, so the
@@ -4008,13 +4807,17 @@ function deriveFromSvg(svg, spec) {
   }
   return { ...legendExtra() };
 }
-function injectHoverStyles(svg, chartType, opts) {
-  if (!opts?.bakeHover || !svg || !chartType) return svg;
+function hoverCssFor(svg, chartType, emphasis) {
+  if (!svg || !chartType) return "";
   const spec = HOVER_SPECS[chartType];
-  if (!spec) return svg;
+  if (!spec) return "";
   const derived = deriveFromSvg(svg, spec);
   const eff = derived.groupAttr ? { ...spec, groupAttr: derived.groupAttr } : spec;
-  const css = buildHoverCss(eff, derived, opts.emphasis);
+  return buildHoverCss(eff, derived, emphasis);
+}
+function injectHoverStyles(svg, chartType, opts) {
+  if (!opts?.bakeHover) return svg;
+  const css = hoverCssFor(svg, chartType, opts.emphasis);
   if (!css) return svg;
   const open = svg.match(/<svg\b[^>]*>/);
   if (open?.index == null) return svg;
@@ -4277,12 +5080,6 @@ function summarizeBoxesAndLines(content) {
   const names = parsed.nodes.map((n) => n.label);
   return `Boxes and lines diagram of ${namedCount(names, "box", "boxes")}, with ${plural(parsed.edges.length, "line", "lines")}.`;
 }
-function summarizeSketch(content) {
-  const parsed = parseSketch(content);
-  if (parsed.error) return null;
-  const names = parsed.nodes.map((n) => n.label);
-  return `Sketch of ${namedCount(names, "shape", "shapes")}, with ${plural(parsed.edges.length, "connection", "connections")}.`;
-}
 function summarizeWhiteboard(content) {
   const parsed = parseWhiteboard(content);
   if (parsed.error) return null;
@@ -4361,6 +5158,13 @@ function summarizeJourneyMap(content) {
   const who = parsed.persona ? ` for ${parsed.persona.name}` : "";
   return `Journey map${who} of ${plural(steps, "step", "steps")}${phases.length > 0 ? ` across ${namedCount(phases, "phase", "phases")}` : ""}.`;
 }
+function summarizeSwot(content) {
+  const parsed = parseSwot(content);
+  if (parsed.error) return null;
+  const counts = parsed.sections.map((s) => `${s.label} ${s.items.length}`);
+  const total = parsed.sections.reduce((n, s) => n + s.items.length, 0);
+  return `SWOT analysis with ${plural(total, "item", "items")}: ${counts.join(", ")}.`;
+}
 function summarizeRaci(content) {
   const parsed = parseRaci(content);
   if (parsed.error) return null;
@@ -4731,7 +5535,6 @@ var SUMMARIZERS = {
   gantt: summarizeGantt,
   pert: summarizePert,
   "boxes-and-lines": summarizeBoxesAndLines,
-  sketch: summarizeSketch,
   whiteboard: summarizeWhiteboard,
   swimlane: summarizeSwimlane,
   family: summarizeFamily,
@@ -4740,6 +5543,7 @@ var SUMMARIZERS = {
   wireframe: summarizeWireframe,
   "journey-map": summarizeJourneyMap,
   raci: summarizeRaci,
+  swot: summarizeSwot,
   body: summarizeBody,
   bracket: summarizeBracket,
   "live-link": summarizeLiveLink,
@@ -4916,10 +5720,19 @@ async function render(source, options) {
   if (category === "data-chart") {
     await acquireDom();
     try {
-      const raw = await renderDataChartD3(renderContent, theme, paletteColors, {
+      const sizeRequest = {
         ...options?.width !== void 0 && { width: options.width },
         ...options?.height !== void 0 && { height: options.height }
-      });
+      };
+      const raw = fitSvgToContent(
+        await renderDataChartD3(
+          renderContent,
+          theme,
+          paletteColors,
+          sizeRequest
+        ),
+        sizeRequest
+      );
       const svg2 = applyRootDesc(
         applyRootA11y(
           injectHoverStyles(raw, chartType, { bakeHover }),
@@ -4974,7 +5787,15 @@ async function render(source, options) {
     );
     svg = applyRootDesc(
       applyRootA11y(
-        injectHoverStyles(svg, chartType, { bakeHover }),
+        // The fold cue (#1741) rides the same gate: a host that opts out of
+        // baked hover opts out of every baked hover rule.
+        // `interactiveFolds: false` drops it, and the toggles' button markup.
+        options?.interactiveFolds === false ? stripFoldAffordance(
+          injectHoverStyles(svg, chartType, { bakeHover })
+        ) : bakeHover ? injectToggleCue(
+          injectHoverStyles(svg, chartType, { bakeHover }),
+          theme
+        ) : svg,
         chartType,
         diagramTitle(content, parsed.chartType)
       ),
@@ -4997,13 +5818,18 @@ async function render(source, options) {
 }
 
 export {
+  EXPORT_FIT_PAD,
+  measureSvgContent,
+  fitSvgToContent,
   orderArcNodes,
   renderArcDiagram,
+  collapsedPertGroupIdsFromSource,
   renderQuadrant,
   renderSlopeChart,
   renderVenn,
   renderWordCloud,
   renderForExport,
   DEFAULT_DIM_OPACITY,
+  hoverCssFor,
   render
 };