@diagrammo/dgmo 0.37.0 → 0.38.0

package/dist/auto.cjs

@@ -602,7 +602,7 @@ function withTagAliases(base, aliases) {
 function isReservedKey(registry, key) {
   return registry.keys.has(key) || registry.tagAliases.has(key);
 }
-var SEQUENCE_REGISTRY, INFRA_REGISTRY, MAP_REGISTRY, ORG_REGISTRY, C4_REGISTRY, ER_REGISTRY, KANBAN_REGISTRY, SITEMAP_REGISTRY, GANTT_REGISTRY, PERT_REGISTRY, BOXES_AND_LINES_REGISTRY, TIMELINE_REGISTRY, MINDMAP_REGISTRY, TECH_RADAR_REGISTRY, CYCLE_REGISTRY, JOURNEY_MAP_REGISTRY, PYRAMID_REGISTRY, RING_REGISTRY, RACI_REGISTRY;
+var SEQUENCE_REGISTRY, INFRA_REGISTRY, MAP_REGISTRY, ORG_REGISTRY, C4_REGISTRY, ER_REGISTRY, KANBAN_REGISTRY, SITEMAP_REGISTRY, GANTT_REGISTRY, PERT_REGISTRY, BOXES_AND_LINES_REGISTRY, TIMELINE_REGISTRY, MINDMAP_REGISTRY, TECH_RADAR_REGISTRY, CYCLE_REGISTRY, JOURNEY_MAP_REGISTRY, PYRAMID_REGISTRY, RING_REGISTRY, TREEMAP_REGISTRY, RACI_REGISTRY;
 var init_reserved_key_registry = __esm({
   "src/utils/reserved-key-registry.ts"() {
     "use strict";
@@ -721,6 +721,7 @@ var init_reserved_key_registry = __esm({
       "color",
       "description"
     ]);
+    TREEMAP_REGISTRY = staticRegistry(["heat"]);
     RACI_REGISTRY = staticRegistry([
       "color",
       "description"
@@ -1150,6 +1151,7 @@ var init_parsing = __esm({
       "journey-map",
       "pyramid",
       "ring",
+      "treemap",
       "raci",
       "rasci",
       "daci",
@@ -11809,6 +11811,10 @@ var init_chart_types = __esm({
         id: "ring",
         description: "Concentric rings showing nested or hierarchical categories (read core-out)"
       },
+      {
+        id: "treemap",
+        description: "Nested rectangles sized by value \u2014 show a hierarchy\u2019s proportions (budgets, disk usage, portfolios) with color by category, value heatmap, or branch"
+      },
       {
         id: "map",
         description: "Geographic concept map: highlight/score regions, drop points of interest, connect with routes or edges"
@@ -18970,7 +18976,7 @@ function parseMap(content, palette) {
       continue;
     }
     if (DIRECTIVE_SET.has(firstWord) && !trimmed.slice(firstWord.length).trimStart().startsWith(":")) {
-      handleDirective(
+      handleDirective2(
         firstWord,
         trimmed.slice(firstWord.length).trim(),
         lineNumber
@@ -19009,7 +19015,7 @@ function parseMap(content, palette) {
     }
   }
   return result;
-  function handleDirective(key, value, line11) {
+  function handleDirective2(key, value, line11) {
     const d = result.directives;
     const dup = (have) => {
       if (have !== void 0)
@@ -22879,6 +22885,344 @@ var init_parser25 = __esm({
   }
 });
 
+// src/treemap/parser.ts
+var parser_exports20 = {};
+__export(parser_exports20, {
+  TREEMAP_DIAGNOSTIC_CODES: () => TREEMAP_DIAGNOSTIC_CODES,
+  parseTreemap: () => parseTreemap
+});
+function isFullyQuoted(s) {
+  return s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"));
+}
+function parseTreemap(content, palette) {
+  const options = {
+    heatColors: [],
+    noValues: false,
+    noPercent: false,
+    noHeaders: false,
+    noLegend: false
+  };
+  const result = {
+    type: "treemap",
+    title: null,
+    titleLineNumber: null,
+    roots: [],
+    tagGroups: [],
+    hasHeat: false,
+    defaultColorMode: "branch",
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushError = (line11, message, code) => {
+    const diag = makeDgmoError(line11, message, "error", code);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const pushWarning = (line11, message, code) => {
+    result.diagnostics.push(makeDgmoError(line11, message, "warning", code));
+  };
+  if (!content?.trim()) {
+    return fail(0, "No content provided");
+  }
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let nodeCounter = 0;
+  let currentTagGroup = null;
+  const aliasMap = /* @__PURE__ */ new Map();
+  const indentStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line11 = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line11.trim();
+    if (!trimmed) {
+      currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!contentStarted) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine && result.titleLineNumber === null && i === 0) {
+        if (firstLine.chartType !== "treemap") {
+          let msg = `Expected chart type "treemap", got "${firstLine.chartType}"`;
+          const hint = suggest(firstLine.chartType, ["treemap"]);
+          if (hint) msg += `. ${hint}`;
+          return fail(lineNumber, msg);
+        }
+        result.title = firstLine.title ?? null;
+        result.titleLineNumber = lineNumber;
+        continue;
+      }
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      emitTagLegacyDiagnostic(tagBlockMatch, lineNumber, result.diagnostics);
+      if (contentStarted) {
+        pushError(
+          lineNumber,
+          "Tag groups must appear before treemap content",
+          "E_TAG_DECLARED_AFTER_CONTENT"
+        );
+        continue;
+      }
+      currentTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      if (tagBlockMatch.alias) {
+        aliasMap.set(
+          tagBlockMatch.alias.toLowerCase(),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      aliasMap.set(
+        tagAttrKey(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (currentTagGroup && !contentStarted) {
+      const indent2 = measureIndent(line11);
+      if (indent2 > 0) {
+        const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+        const { label, color } = extractColor(
+          cleanEntry,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (isDefault) {
+          currentTagGroup.defaultValue = label;
+        } else if (currentTagGroup.entries.length === 0) {
+          currentTagGroup.defaultValue = label;
+        }
+        currentTagGroup.entries.push({
+          value: label,
+          color: color ?? AUTO_TAG_COLOR_SENTINEL,
+          lineNumber
+        });
+        continue;
+      }
+      currentTagGroup = null;
+    }
+    if (!contentStarted && measureIndent(line11) === 0) {
+      if (handleDirective(trimmed, options, result, pushWarning, lineNumber)) {
+        continue;
+      }
+    }
+    contentStarted = true;
+    currentTagGroup = null;
+    const indent = measureIndent(line11);
+    const node = parseNodeLine3(
+      trimmed,
+      lineNumber,
+      ++nodeCounter,
+      aliasMap,
+      result.diagnostics,
+      pushWarning
+    );
+    if (node.heat !== void 0) result.hasHeat = true;
+    attachNode4(node, indent, indentStack, result);
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  const allNodes = [];
+  const collectAll = (nodes) => {
+    for (const n of nodes) {
+      allNodes.push(n);
+      collectAll(n.children);
+    }
+  };
+  collectAll(result.roots);
+  for (const n of allNodes) {
+    const node = n;
+    const isBranch = node.children.length > 0;
+    if (isBranch) {
+      if (node.value !== void 0) {
+        pushWarning(
+          node.lineNumber,
+          `"${node.label}" is a branch \u2014 its trailing number is ignored; the area is the auto-sum of its children`,
+          TREEMAP_DIAGNOSTIC_CODES.BRANCH_VALUE_IGNORED
+        );
+        delete node.value;
+      }
+    } else if (node.value === void 0) {
+      pushWarning(
+        node.lineNumber,
+        `Leaf "${node.label}" has no value \u2014 it renders with zero area`,
+        TREEMAP_DIAGNOSTIC_CODES.LEAF_NO_VALUE
+      );
+      node.value = 0;
+    } else if (node.value < 0) {
+      pushError(
+        node.lineNumber,
+        `Leaf "${node.label}" has a negative value (${node.value}) \u2014 treemap sizes must be \u2265 0`,
+        TREEMAP_DIAGNOSTIC_CODES.NEGATIVE_VALUE
+      );
+    }
+  }
+  if (result.hasHeat || options.heatLabel !== void 0) {
+    result.hasHeat = true;
+  }
+  if (result.tagGroups.length > 0) {
+    validateTagValues(allNodes, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning);
+    cascadeTagMetadata(result.roots, result.tagGroups);
+  }
+  result.defaultColorMode = resolveDefaultColorMode(result);
+  if (result.roots.length === 0 && !result.error) {
+    const diag = makeDgmoError(1, "No nodes found in treemap");
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function handleDirective(trimmed, options, result, pushWarning, lineNumber) {
+  const depthMatch = trimmed.match(/^depth\s+(-?\d+)\s*$/i);
+  if (depthMatch) {
+    const n = parseInt(depthMatch[1], 10);
+    if (n >= 1) options.maxDepth = n;
+    else pushWarning(lineNumber, '"depth" must be \u2265 1 \u2014 ignored');
+    return true;
+  }
+  if (/^other-below\b/i.test(trimmed)) {
+    pushWarning(
+      lineNumber,
+      '"other-below" is no longer supported \u2014 remove this line'
+    );
+    return true;
+  }
+  const heatMatch = trimmed.match(/^heat\s+(.+)$/i);
+  if (heatMatch) {
+    const { label, low, high } = peelRampColors(heatMatch[1].trim());
+    options.heatLabel = label || "Value";
+    const colors = [];
+    if (low !== void 0) colors.push(low);
+    if (high !== void 0) colors.push(high);
+    options.heatColors = colors;
+    result.hasHeat = true;
+    return true;
+  }
+  const noMatch = trimmed.match(/^no-(values|percent|headers|legend)\s*$/i);
+  if (noMatch) {
+    const key = noMatch[1].toLowerCase();
+    if (key === "values") options.noValues = true;
+    else if (key === "percent") options.noPercent = true;
+    else if (key === "headers") options.noHeaders = true;
+    else if (key === "legend") options.noLegend = true;
+    return true;
+  }
+  return false;
+}
+function resolveDefaultColorMode(result) {
+  if (result.tagGroups.length > 0) return "tag";
+  if (result.hasHeat) return "heat";
+  return "branch";
+}
+function parseNodeLine3(trimmed, lineNumber, counter, aliasMap, diagnostics, pushWarning) {
+  if (trimmed.includes("|")) {
+    diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        pipeOperatorRemovedMessage(),
+        "error",
+        METADATA_DIAGNOSTIC_CODES.PIPE_OPERATOR_REMOVED
+      )
+    );
+  }
+  const registry = withTagAliases(TREEMAP_REGISTRY, new Set(aliasMap.keys()));
+  const split = splitNameAndMeta(
+    trimmed,
+    registry,
+    aliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => diagnostics.push(makeDgmoError(lineNumber, msg, "warning")),
+    split.name
+  );
+  const metadata = { ...split.meta };
+  let heat;
+  if ("heat" in metadata) {
+    const h = parseFloat(metadata["heat"].replace(/_/g, ""));
+    if (Number.isFinite(h)) heat = h;
+    delete metadata["heat"];
+  }
+  const rawName = split.name;
+  let label;
+  let value;
+  if (isFullyQuoted(rawName)) {
+    label = stripQuotes(rawName);
+  } else {
+    const vm = rawName.match(VALUE_TOKEN_RE);
+    if (vm) {
+      const labelPart = vm[1].trim();
+      const token = vm[2];
+      if (token.includes(",")) {
+        pushWarning(lineNumber, dataCommaRemovedMessage(labelPart));
+      }
+      const cleaned = token.replace(/[_,]/g, "");
+      const parsed = parseFloat(cleaned);
+      if (Number.isFinite(parsed)) {
+        value = parsed;
+        label = isFullyQuoted(labelPart) ? stripQuotes(labelPart) : labelPart;
+      } else {
+        label = rawName;
+      }
+    } else {
+      label = rawName;
+    }
+  }
+  return {
+    id: `treemap-node-${counter}`,
+    label,
+    ...value !== void 0 && { value },
+    ...heat !== void 0 && { heat },
+    metadata,
+    children: [],
+    lineNumber
+  };
+}
+function attachNode4(node, indent, indentStack, result) {
+  while (indentStack.length > 0) {
+    const top = indentStack[indentStack.length - 1];
+    if (top.indent < indent) break;
+    indentStack.pop();
+  }
+  if (indentStack.length > 0) {
+    const parent = indentStack[indentStack.length - 1].node;
+    parent.children.push(node);
+  } else {
+    result.roots.push(node);
+  }
+  indentStack.push({ node, indent });
+}
+var TREEMAP_DIAGNOSTIC_CODES, VALUE_TOKEN_RE;
+var init_parser26 = __esm({
+  "src/treemap/parser.ts"() {
+    "use strict";
+    init_diagnostics();
+    init_tag_groups();
+    init_parsing();
+    init_reserved_key_registry();
+    TREEMAP_DIAGNOSTIC_CODES = {
+      NEGATIVE_VALUE: "E_TREEMAP_NEGATIVE_VALUE",
+      LEAF_NO_VALUE: "W_TREEMAP_LEAF_NO_VALUE",
+      BRANCH_VALUE_IGNORED: "W_TREEMAP_BRANCH_VALUE_IGNORED"
+    };
+    VALUE_TOKEN_RE = /^(.+?)\s+(-?\d[\d_,.]*)$/;
+  }
+});
+
 // src/raci/variants.ts
 function inferVariant(markers) {
   let hasD = false;
@@ -23133,8 +23477,8 @@ var init_variants = __esm({
 });
 
 // src/raci/parser.ts
-var parser_exports20 = {};
-__export(parser_exports20, {
+var parser_exports21 = {};
+__export(parser_exports21, {
   allTasks: () => allTasks,
   parseRaci: () => parseRaci
 });
@@ -23655,7 +23999,7 @@ function* allTasks(parsed) {
   }
 }
 var RACI_CHART_TYPE_IDS, CHART_TYPE_VARIANT_LOCK, VARIANT_LOCK_DIRECTIVES, KNOWN_OPTIONS10, KNOWN_BOOLEANS7, REMOVED_BOOLEANS3, PHASE_RE2, PHASE_PALETTE_COLOR_RE, ROLE_ASSIGNMENT_RE;
-var init_parser26 = __esm({
+var init_parser27 = __esm({
   "src/raci/parser.ts"() {
     "use strict";
     init_diagnostics();
@@ -23901,6 +24245,7 @@ var init_chart_type_registry = __esm({
     init_parser24();
     init_parser25();
     init_parser26();
+    init_parser27();
     CHART_TYPE_REGISTRY = [
       // ── Structured diagrams ───────────────────────────────────
       {
@@ -24041,6 +24386,9 @@ var init_chart_type_registry = __esm({
       { id: "cycle", category: "visualization", parse: parseCycle },
       { id: "pyramid", category: "visualization", parse: parsePyramid },
       { id: "ring", category: "visualization", parse: parseRing },
+      // Treemap: squarified hierarchy. No measure/minDims — a treemap fills whatever
+      // rectangle it's given and has no intrinsic aspect/size (F11).
+      { id: "treemap", category: "visualization", parse: parseTreemap },
       // ── Geographic map (own parser → resolver → layout → renderer) ──
       { id: "map", category: "visualization", parse: parseMap }
     ];
@@ -26773,10 +27121,10 @@ async function renderSitemapForExport(content, theme, palette) {
   const parsed = parseSitemap2(content, effectivePalette);
   if (parsed.error || parsed.roots.length === 0) return "";
   const sitemapLayout = layoutSitemap2(parsed, void 0, null, void 0, true);
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = parsed.title ? 30 : 0;
-  const exportWidth = sitemapLayout.width + PADDING3 * 2;
-  const exportHeight = sitemapLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = sitemapLayout.width + PADDING4 * 2;
+  const exportHeight = sitemapLayout.height + PADDING4 * 2 + titleOffset;
   const container = document.createElement("div");
   container.style.width = `${exportWidth}px`;
   container.style.height = `${exportHeight}px`;
@@ -31804,6 +32152,10 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
   const reserveEdgeLabels = opts?.reserveEdgeLabels ?? false;
   const onProgress = opts?.onProgress;
   const tick = onProgress ? () => new Promise((r) => setTimeout(r)) : () => void 0;
+  const YIELD_AFTER_MS = 150;
+  const YIELD_EVERY_MS = 30;
+  const searchStart = performance.now();
+  let lastYield = searchStart;
   const collapsedGroupLabels = /* @__PURE__ */ new Set();
   if (collapseInfo) {
     const missing = /* @__PURE__ */ new Set();
@@ -32233,7 +32585,11 @@ async function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
   const step = async (phase) => {
     if (!onProgress) return;
     onProgress(++progressDone, progressTotal, phase);
-    await tick();
+    const now = performance.now();
+    if (now - searchStart > YIELD_AFTER_MS && now - lastYield > YIELD_EVERY_MS) {
+      lastYield = now;
+      await tick();
+    }
   };
   const pool = [];
   for (const cfg of configs) {
@@ -50623,7 +50979,7 @@ function computeEdgeLabelPosition(midAngle, radius, cx, cy, lineCount, labelPxW,
   };
 }
 function fitToCanvas(nodes, edges, parsed, _cx, _cy, radius, width, height, _isClockwise) {
-  const PADDING3 = 30;
+  const PADDING4 = 30;
   let contentMinX = Infinity, contentMaxX = -Infinity;
   let contentMinY = Infinity, contentMaxY = -Infinity;
   for (const n of nodes) {
@@ -50665,13 +51021,13 @@ function fitToCanvas(nodes, edges, parsed, _cx, _cy, radius, width, height, _isC
     contentMinY = Math.min(contentMinY, le.labelY - 12);
     contentMaxY = Math.max(contentMaxY, le.labelY + (lineCount - 1) * 15);
   }
-  const overflowX = Math.max(0, PADDING3 - contentMinX) + Math.max(0, contentMaxX - (width - PADDING3));
-  const overflowY = Math.max(0, PADDING3 - contentMinY) + Math.max(0, contentMaxY - (height - PADDING3));
+  const overflowX = Math.max(0, PADDING4 - contentMinX) + Math.max(0, contentMaxX - (width - PADDING4));
+  const overflowY = Math.max(0, PADDING4 - contentMinY) + Math.max(0, contentMaxY - (height - PADDING4));
   if (overflowX <= 0 && overflowY <= 0) return null;
   const contentW = contentMaxX - contentMinX;
   const contentH = contentMaxY - contentMinY;
-  const availW = width - 2 * PADDING3;
-  const availH = height - 2 * PADDING3;
+  const availW = width - 2 * PADDING4;
+  const availH = height - 2 * PADDING4;
   const shrink = Math.min(availW / contentW, availH / contentH);
   const newRadius = Math.max(80, radius * shrink);
   return { radius: newRadius };
@@ -50869,7 +51225,7 @@ function renderCycle(container, parsed, palette, isDark, onClickItem, exportDims
     }
     edgeLabelInfo.push({ le, edge });
   }
-  const HEADER_H = 36 * layout.scale;
+  const HEADER_H2 = 36 * layout.scale;
   const scaledNodeFont = Math.max(6, Math.round(NODE_FONT_SIZE7 * layout.scale));
   const scaledEdgeLabelFont = Math.max(
     6,
@@ -50933,10 +51289,10 @@ function renderCycle(container, parsed, palette, isDark, onClickItem, exportDims
       const rx = 6;
       nodeG.append("rect").attr("x", ln.x - nodeW / 2).attr("y", ln.y - nodeH / 2).attr("width", nodeW).attr("height", nodeH).attr("rx", rx).attr("ry", rx).attr("fill", fillColor).attr("stroke", solidColor).attr("stroke-width", 2);
       if (hasDesc) {
-        const headerCenterY = ln.y - nodeH / 2 + HEADER_H / 2;
+        const headerCenterY = ln.y - nodeH / 2 + HEADER_H2 / 2;
         const labelText = nodeG.append("text").attr("x", ln.x).attr("y", headerCenterY + scaledNodeFont / 3).attr("text-anchor", "middle").attr("fill", textColor).attr("font-family", FONT_FAMILY).attr("font-size", scaledNodeFont).attr("font-weight", "600");
         renderInlineText(labelText, node.label, palette, scaledNodeFont);
-        const sepY = ln.y - nodeH / 2 + HEADER_H;
+        const sepY = ln.y - nodeH / 2 + HEADER_H2;
         nodeG.append("line").attr("x1", ln.x - nodeW / 2).attr("y1", sepY).attr("x2", ln.x + nodeW / 2).attr("y2", sepY).attr("stroke", solid ? descColor : solidColor).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
         const descStartY = sepY + 4 + scaledDescFont;
         const descPadX = Math.max(8, 12 * layout.scale);
@@ -55748,7 +56104,9 @@ function mapContentAspect(resolved, data, ref = REF) {
 function mapExportDimensions(resolved, data, baseWidth = 1200, aspectOverride) {
   const useOverride = aspectOverride !== void 0 && Number.isFinite(aspectOverride) && aspectOverride > 0;
   const raw = useOverride ? aspectOverride : mapContentAspect(resolved, data);
-  const clamped = useOverride ? raw : Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, raw));
+  const isGlobal = !useOverride && buildMapProjection(resolved, data).fitIsGlobal;
+  const target = isGlobal ? raw / GLOBAL_HEIGHT_BOOST : raw;
+  const clamped = useOverride ? raw : Math.max(ASPECT_MIN, Math.min(ASPECT_MAX, target));
   const width = baseWidth;
   let height = Math.round(width / clamped);
   let chromeReserve = 0;
@@ -55761,10 +56119,10 @@ function mapExportDimensions(resolved, data, baseWidth = 1200, aspectOverride) {
     height = Math.round(chromeReserve + MIN_MAP_BAND);
     floored = true;
   }
-  const preferContain = useOverride ? floored : clamped !== raw || floored;
+  const preferContain = useOverride ? floored : clamped !== target || floored;
   return { width, height, preferContain };
 }
-var import_d3_geo3, FIT_PAD2, TITLE_GAP, ASPECT_MAX, ASPECT_MIN, MIN_MAP_BAND, FALLBACK_ASPECT, REF;
+var import_d3_geo3, FIT_PAD2, TITLE_GAP, ASPECT_MAX, ASPECT_MIN, GLOBAL_HEIGHT_BOOST, MIN_MAP_BAND, FALLBACK_ASPECT, REF;
 var init_dimensions = __esm({
   "src/map/dimensions.ts"() {
     "use strict";
@@ -55775,6 +56133,7 @@ var init_dimensions = __esm({
     TITLE_GAP = 16;
     ASPECT_MAX = 3;
     ASPECT_MIN = 0.9;
+    GLOBAL_HEIGHT_BOOST = 1.12;
     MIN_MAP_BAND = 200;
     FALLBACK_ASPECT = 1.5;
     REF = 1e3;
@@ -56564,9 +56923,469 @@ var init_renderer18 = __esm({
   }
 });
 
-// src/raci/renderer.ts
+// src/treemap/layout.ts
+function toDatum(node) {
+  if (node.children.length === 0) {
+    return {
+      ref: node,
+      label: node.label,
+      value: node.value ?? 0,
+      ...node.heat !== void 0 && { heat: node.heat },
+      lineNumber: node.lineNumber
+    };
+  }
+  return {
+    ref: node,
+    label: node.label,
+    ...node.heat !== void 0 && { heat: node.heat },
+    lineNumber: node.lineNumber,
+    children: node.children.map((c) => toDatum(c))
+  };
+}
+function datumHeat(node) {
+  if (node.data.heat !== void 0) return node.data.heat;
+  const xs = [];
+  for (const l of node.leaves()) {
+    if (l.data.heat !== void 0) xs.push(l.data.heat);
+  }
+  if (xs.length === 0) return void 0;
+  return xs.reduce((a, b) => a + b, 0) / xs.length;
+}
+function layoutTreemap(roots, opts) {
+  const maxDepth = opts.maxDepth ?? Infinity;
+  const rootDatum = {
+    label: "__root",
+    children: roots.map((r) => toDatum(r))
+  };
+  const h = (0, import_d3_hierarchy2.hierarchy)(rootDatum).sum((d) => d.children?.length ? 0 : d.value ?? 0).sort((a, b) => (b.value ?? 0) - (a.value ?? 0));
+  const hroot = (0, import_d3_hierarchy2.treemap)().tile(import_d3_hierarchy2.treemapSquarify).size([opts.width, opts.height]).paddingOuter(opts.paddingOuter ?? 3).paddingTop(opts.headerH > 0 ? opts.headerH : opts.paddingInner ?? 2).paddingInner(opts.paddingInner ?? 2).round(true)(h);
+  const total = hroot.value ?? 0;
+  (hroot.children ?? []).forEach((top, i) => {
+    top.each((d) => {
+      d._topIndex = i;
+    });
+  });
+  const cells = [];
+  for (const d of hroot.descendants()) {
+    if (d.depth === 0) continue;
+    if (d.depth > maxDepth) continue;
+    const hasChildren = !!d.children && d.children.length > 0;
+    const isCollapsed = hasChildren && d.depth >= maxDepth;
+    const isContainer = hasChildren && !isCollapsed;
+    const path = [];
+    let p = d;
+    while (p && p.depth > 0) {
+      path.unshift(p.data.label);
+      p = p.parent;
+    }
+    const heatVal = datumHeat(d);
+    cells.push({
+      node: d.data.ref ?? null,
+      label: d.data.label,
+      x0: d.x0,
+      y0: d.y0,
+      x1: d.x1,
+      y1: d.y1,
+      depth: d.depth,
+      value: d.value ?? 0,
+      isContainer,
+      isCollapsed,
+      topIndex: d._topIndex ?? 0,
+      pctOfRoot: total > 0 ? (d.value ?? 0) / total : 0,
+      pctOfParent: d.parent && (d.parent.value ?? 0) > 0 ? (d.value ?? 0) / (d.parent.value ?? 1) : 1,
+      ...heatVal !== void 0 && { heat: heatVal },
+      path,
+      ...d.data.lineNumber !== void 0 && { lineNumber: d.data.lineNumber }
+    });
+  }
+  return { cells, total };
+}
+var import_d3_hierarchy2;
+var init_layout16 = __esm({
+  "src/treemap/layout.ts"() {
+    "use strict";
+    import_d3_hierarchy2 = require("d3-hierarchy");
+  }
+});
+
+// src/treemap/renderer.ts
 var renderer_exports19 = {};
 __export(renderer_exports19, {
+  compactNumber: () => compactNumber2,
+  renderTreemap: () => renderTreemap,
+  renderTreemapForExport: () => renderTreemapForExport
+});
+function renderTreemapForExport(container, parsed, palette, isDark, exportDims, options) {
+  renderTreemap(container, parsed, palette, isDark, exportDims, {
+    exportMode: true,
+    ...options
+  });
+}
+function renderTreemap(container, parsed, palette, isDark, exportDims, options = {}) {
+  if (parsed.error || parsed.roots.length === 0) return;
+  void isDark;
+  d3Selection26.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const width = exportDims?.width ?? container.clientWidth;
+  const height = exportDims?.height ?? container.clientHeight;
+  if (width <= 0 || height <= 0) return;
+  const mode = resolveColorMode(parsed, options.colorMode);
+  const opts = parsed.options;
+  const exportMode = options.exportMode ?? false;
+  const seriesColorsTop = getSeriesColors(palette);
+  const showTitle = !!parsed.title;
+  const titleH = showTitle ? TITLE_BAND : 0;
+  const heat = buildHeatScale(parsed, palette);
+  const legend = !opts.noLegend ? buildLegend(mode, parsed, heat, seriesColorsTop, options.colorOffset ?? 0) : null;
+  const legendReserve = legend ? getMaxLegendReservedHeight(
+    { groups: legend.groups, position: LEGEND_POSITION, mode: "preview" },
+    width
+  ) + LEGEND_GROUP_GAP : 0;
+  const headerH = opts.noHeaders ? 0 : HEADER_H;
+  const areaX = PADDING3;
+  const areaY = titleH + legendReserve + PADDING3;
+  const areaW = Math.max(1, width - PADDING3 * 2);
+  const areaH = Math.max(1, height - areaY - PADDING3);
+  const layout = layoutTreemap(parsed.roots, {
+    width: areaW,
+    height: areaH,
+    headerH,
+    ...options.maxDepth !== void 0 && { maxDepth: options.maxDepth }
+  });
+  const svg = d3Selection26.select(container).append("svg").attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`).attr("preserveAspectRatio", "xMidYMin meet").attr("xmlns", "http://www.w3.org/2000/svg").attr("class", "dgmo-treemap").style("font-family", FONT_FAMILY);
+  svg.append("style").text(
+    ".dgmo-treemap-focus{opacity:.3;transition:opacity .12s}.dgmo-treemap-cell:hover .dgmo-treemap-focus{opacity:.7}"
+  );
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", palette.bg);
+  if (showTitle) {
+    const title = svg.append("text").attr("class", "chart-title").attr("x", width / 2).attr("y", TITLE_Y).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-family", FONT_FAMILY).attr("font-size", TITLE_FONT_SIZE).attr("font-weight", TITLE_FONT_WEIGHT).text(parsed.title);
+    if (parsed.titleLineNumber !== null) {
+      title.attr("data-line-number", parsed.titleLineNumber);
+    }
+  }
+  const root = svg.append("g").attr("class", "dgmo-treemap-cells").attr("transform", `translate(${areaX},${areaY})`);
+  const seriesColors2 = seriesColorsTop;
+  const colorOffset = options.colorOffset ?? 0;
+  const activeGroup = parsed.tagGroups.length > 0 ? parsed.tagGroups[0].name : null;
+  const rootIndexByLabel = new Map(parsed.roots.map((r, i) => [r.label, i]));
+  const colorOf = (cell) => {
+    if (mode === "heat") {
+      return cell.heat !== void 0 && heat ? heat.scale(cell.heat) : MUTED_FILL;
+    }
+    if (mode === "tag") {
+      if (!cell.node) return MUTED_FILL;
+      return resolveTagColor(cell.node.metadata, parsed.tagGroups, activeGroup) ?? MUTED_FILL;
+    }
+    const topLabel = cell.path[0] ?? cell.label;
+    const idx = (rootIndexByLabel.get(topLabel) ?? cell.topIndex) + colorOffset;
+    const hue = seriesColors2[idx % seriesColors2.length];
+    if (cell.depth <= 1) return hue;
+    const keepPct = Math.max(55, 100 - (cell.depth - 1) * 18);
+    return mix(hue, palette.bg, keepPct);
+  };
+  for (const cell of layout.cells) {
+    const w = Math.max(0, cell.x1 - cell.x0);
+    const h = Math.max(0, cell.y1 - cell.y0);
+    if (w <= 0 || h <= 0) continue;
+    const baseColor = colorOf(cell);
+    const fill2 = cell.isContainer ? baseColor : mix(baseColor, palette.bg, LEAF_MUTE_PCT);
+    const drillable = cell.isContainer || cell.isCollapsed;
+    const g = root.append("g").attr("class", "dgmo-treemap-cell").attr("transform", `translate(${cell.x0},${cell.y0})`).attr("data-node-path", cell.path.join(" / "));
+    if (cell.lineNumber !== void 0) {
+      g.attr("data-line-number", cell.lineNumber);
+    }
+    if (cell.heat !== void 0) g.attr("data-heat", cell.heat);
+    if (cell.node && activeGroup) {
+      const key = tagAttrKey(activeGroup);
+      const tagVal = cell.node.metadata[key];
+      if (tagVal) g.attr(`data-tag-${key}`, tagVal);
+    }
+    const rect = g.append("rect").attr(
+      "class",
+      cell.isContainer ? "dgmo-treemap-rect branch" : "dgmo-treemap-rect"
+    ).attr("width", w).attr("height", h).attr("rx", 2).attr("fill", fill2).attr("fill-opacity", 1).attr("stroke", palette.bg).attr("stroke-width", cell.isContainer ? 1 : 0);
+    if (drillable && options.onClickItem && cell.lineNumber !== void 0) {
+      const ln = cell.lineNumber;
+      rect.style("cursor", "pointer").on("click", () => options.onClickItem(ln));
+    }
+    const ink = contrastText(
+      fill2,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    );
+    if (cell.isContainer && headerH > 0 && w > 34 && h > headerH) {
+      const valParts = [];
+      if (!opts.noValues) valParts.push(compactNumber2(cell.value));
+      if (!opts.noPercent) valParts.push(formatPct(cell.pctOfRoot));
+      const valStr = valParts.join(" \xB7 ");
+      const ICON_RESERVE = drillable ? 16 : 4;
+      const showVal = valStr.length > 0 && w > 110;
+      const valW = showVal ? measureText(valStr, 10.5) : 0;
+      const labelMax = w - 8 - ICON_RESERVE - (showVal ? valW + 10 : 0);
+      g.append("text").attr("class", "dgmo-treemap-header").attr("x", 6).attr("y", 13).attr("font-size", 11).attr("font-weight", 700).attr("fill", ink).text(clipLabel(cell.label, Math.max(0, labelMax), 11));
+      if (showVal) {
+        g.append("text").attr("class", "dgmo-treemap-header-value").attr("x", w - ICON_RESERVE - 4).attr("y", 13).attr("text-anchor", "end").attr("font-size", 10.5).attr("fill", ink).attr("opacity", 0.75).text(valStr);
+      }
+    }
+    const PAD = Math.max(4, Math.min(14, Math.floor(Math.min(w, h) / 5)));
+    const MIN_FS = 7;
+    if (!cell.isContainer && w >= 2 * PAD + 8 && h >= 2 * PAD + 8) {
+      const maxW = w - 2 * PAD;
+      let fs = clamp3(Math.round(Math.min(w / 3.6, h / 3.4)), MIN_FS, 72);
+      const nameW = measureText(cell.label, fs) * 1.06;
+      if (nameW > maxW) fs = Math.max(MIN_FS, Math.floor(fs * maxW / nameW));
+      const tg = clamp3((fs - MIN_FS) / (72 - MIN_FS), 0, 1);
+      const nameOpacity = 0.95 - tg * 0.5;
+      const vfs = clamp3(Math.round(fs * 0.42), 11, 28);
+      const valOpacity = Math.max(0.45, nameOpacity - 0.1);
+      let y = PAD + Math.round(fs * 0.78);
+      g.append("text").attr("class", "dgmo-treemap-label").attr("x", PAD).attr("y", y).attr("font-size", fs).attr("font-weight", 600).attr("fill", ink).attr("opacity", nameOpacity).text(clipLabel(cell.label, maxW, fs));
+      const valParts = [
+        opts.noValues ? "" : compactNumber2(cell.value),
+        opts.noPercent ? "" : formatPct(cell.pctOfRoot)
+      ].filter(Boolean);
+      const combined = valParts.join(" \xB7 ");
+      const nameBaseY = y;
+      const addLineAt = (text, yy, size, opacity) => {
+        g.append("text").attr("class", "dgmo-treemap-value").attr("x", PAD).attr("y", yy).attr("font-size", size).attr("fill", ink).attr("opacity", opacity).text(text);
+      };
+      if (combined) {
+        const fitsW = measureText(combined, vfs) <= maxW;
+        const roomBelow = h - PAD > y + vfs + 6;
+        if (fitsW && roomBelow) {
+          addLineAt(combined, y + vfs + 6, vfs, valOpacity);
+        } else if (fitsW) {
+          const ivfs = clamp3(Math.round(fs * 0.5), 11, Math.max(11, vfs));
+          const rendered = clipLabel(cell.label, maxW, fs);
+          const nW = measureText(rendered, fs) * 1.12;
+          const gap = Math.max(12, Math.round(fs * 0.25));
+          if (PAD + nW + gap + measureText(combined, ivfs) <= w - PAD) {
+            g.append("text").attr("class", "dgmo-treemap-value").attr("x", PAD + nW + gap).attr("y", nameBaseY).attr("font-size", ivfs).attr("fill", ink).attr("opacity", valOpacity).text(combined);
+          }
+        } else if (valParts.length === 2) {
+          if (h - PAD > y + vfs + 6) {
+            y += vfs + 6;
+            addLineAt(valParts[0], y, vfs, valOpacity);
+          }
+          const pfs = Math.max(10, Math.round(vfs * 0.9));
+          if (h - PAD > y + pfs + 4) {
+            y += pfs + 4;
+            addLineAt(valParts[1], y, pfs, valOpacity);
+          }
+        } else if (h - PAD > y + vfs + 6) {
+          addLineAt(combined, y + vfs + 6, vfs, valOpacity);
+        }
+      }
+    }
+    if (drillable && w > 30 && h > 22) {
+      drawFocusIcon(g, w, ink, 9);
+    }
+  }
+  if (legend) {
+    const legendG = svg.append("g").attr("class", "dgmo-treemap-legend").attr("transform", `translate(0, ${titleH})`);
+    renderIntegratedLegend(legendG, {
+      groups: legend.groups,
+      palette: {
+        bg: palette.bg,
+        surface: palette.surface,
+        text: palette.text,
+        textMuted: palette.textMuted,
+        primary: palette.primary
+      },
+      isDark,
+      width,
+      mode: exportMode ? "export" : "preview",
+      position: LEGEND_POSITION,
+      activeGroup: legend.activeGroup,
+      // The color-mode switcher is the legend itself: each applicable mode is a
+      // group pill; the active one is the open capsule, the rest are clickable
+      // pills that switch mode. Export shows only the active group.
+      showInactivePills: !exportMode,
+      showEmptyGroups: !exportMode,
+      ...options.onSelectMode !== void 0 && {
+        callbacks: {
+          onGroupToggle: (name) => {
+            const m = legend.modeByName.get(name);
+            if (m) options.onSelectMode(m);
+          }
+        }
+      }
+    });
+  }
+}
+function buildLegend(activeMode, parsed, heat, seriesColors2, colorOffset) {
+  const groups = [];
+  const modeByName = /* @__PURE__ */ new Map();
+  let activeGroup = null;
+  if (parsed.tagGroups.length > 0) {
+    const tg = parsed.tagGroups[0];
+    const used = /* @__PURE__ */ new Set();
+    const collect = (nodes) => {
+      for (const n of nodes) {
+        const v = n.metadata[tagAttrKey(tg.name)];
+        if (v) used.add(v.toLowerCase());
+        collect(n.children);
+      }
+    };
+    collect(parsed.roots);
+    groups.push({
+      name: tg.name,
+      entries: tg.entries.filter((e) => used.has(e.value.toLowerCase())).map((e) => ({ value: e.value, color: e.color }))
+    });
+    modeByName.set(tg.name, "tag");
+    if (activeMode === "tag") activeGroup = tg.name;
+  }
+  if (heat) {
+    const name = parsed.options.heatLabel ?? "Value";
+    groups.push({
+      name,
+      entries: [],
+      gradient: {
+        min: heat.min,
+        max: heat.max,
+        low: heat.stops[0],
+        high: heat.stops[heat.stops.length - 1]
+      }
+    });
+    modeByName.set(name, "heat");
+    if (activeMode === "heat") activeGroup = name;
+  }
+  groups.push({
+    name: "Branch",
+    entries: parsed.roots.map((r, i) => ({
+      value: r.label,
+      color: seriesColors2[(i + colorOffset) % seriesColors2.length]
+    }))
+  });
+  modeByName.set("Branch", "branch");
+  if (activeMode === "branch" || activeGroup === null) activeGroup = "Branch";
+  return { groups, activeGroup, modeByName };
+}
+function buildHeatScale(parsed, palette) {
+  if (!parsed.hasHeat) return null;
+  const values = [];
+  const collect = (nodes) => {
+    for (const n of nodes) {
+      if (typeof n.heat === "number") values.push(n.heat);
+      collect(n.children);
+    }
+  };
+  collect(parsed.roots);
+  if (values.length === 0) return null;
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const signed = min < 0 && max > 0;
+  const neutral = palette.surface;
+  const explicit = parsed.options.heatColors.map((c) => resolveColor(c, palette) ?? c).filter((c) => !!c);
+  let stops;
+  let domain;
+  if (explicit.length >= 2) {
+    stops = [explicit[0], neutral, explicit[1]];
+    const mid = signed ? 0 : (min + max) / 2;
+    domain = [min, mid, max];
+  } else if (explicit.length === 1) {
+    stops = [neutral, explicit[0]];
+    domain = [min, max];
+  } else if (signed) {
+    stops = [palette.colors.red, neutral, palette.colors.green];
+    domain = [min, 0, max];
+  } else {
+    stops = [neutral, palette.primary];
+    domain = [min, max];
+  }
+  if (domain[0] === domain[domain.length - 1]) {
+    const last = stops[stops.length - 1];
+    return { scale: () => last, min, max, stops, signed };
+  }
+  const linear = (0, import_d3_scale.scaleLinear)().domain(domain).range(stops).clamp(true);
+  return { scale: (v) => toHex(linear(v)), min, max, stops, signed };
+}
+function toHex(c) {
+  if (c.startsWith("#")) return c;
+  const m = c.match(/rgba?\(([^)]+)\)/);
+  if (!m) return c;
+  const parts = m[1].split(",").map((s) => Math.round(parseFloat(s)));
+  const h = (n) => Math.max(0, Math.min(255, n || 0)).toString(16).padStart(2, "0");
+  return `#${h(parts[0] ?? 0)}${h(parts[1] ?? 0)}${h(parts[2] ?? 0)}`;
+}
+function resolveColorMode(parsed, override) {
+  let mode = override ?? parsed.defaultColorMode;
+  if (mode === "tag" && parsed.tagGroups.length === 0) {
+    mode = parsed.hasHeat ? "heat" : "branch";
+  }
+  if (mode === "heat" && !parsed.hasHeat) mode = "branch";
+  return mode;
+}
+function drawFocusIcon(g, w, ink, cy) {
+  const r = 4.5;
+  const cx = w - r - 5;
+  const fi = g.append("g").attr("class", "dgmo-treemap-focus").attr("data-export-ignore", "true");
+  fi.append("rect").attr("x", cx - 9).attr("y", cy - 9).attr("width", 18).attr("height", 18).attr("fill", "transparent");
+  fi.append("circle").attr("cx", cx).attr("cy", cy).attr("r", r).attr("fill", "none").attr("stroke", ink).attr("stroke-width", 1.25);
+  fi.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 1.4).attr("fill", ink);
+}
+function clamp3(x, lo, hi) {
+  return Math.max(lo, Math.min(hi, x));
+}
+function clipLabel(s, maxWidth, fs) {
+  if (measureText(s, fs) <= maxWidth) return s;
+  let lo = 0;
+  let hi = s.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (measureText(s.slice(0, mid) + "\u2026", fs) <= maxWidth) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo <= 0 ? "" : s.slice(0, lo) + "\u2026";
+}
+function compactNumber2(v) {
+  const abs = Math.abs(v);
+  if (abs >= 1e9) return strip(v / 1e9) + "B";
+  if (abs >= 1e6) return strip(v / 1e6) + "M";
+  if (abs >= 1e3) return strip(v / 1e3) + "k";
+  return strip(Math.round(v * 100) / 100);
+}
+function strip(n) {
+  return parseFloat(
+    n.toFixed(n < 10 && !Number.isInteger(n) ? 1 : 0)
+  ).toString();
+}
+function formatPct(frac) {
+  const pct = frac * 100;
+  if (pct >= 10) return `${Math.round(pct)}%`;
+  if (pct >= 1) return `${pct.toFixed(0)}%`;
+  return `${pct.toFixed(1)}%`;
+}
+var d3Selection26, import_d3_scale, PADDING3, HEADER_H, TITLE_BAND, MUTED_FILL, LEAF_MUTE_PCT, LEGEND_POSITION;
+var init_renderer19 = __esm({
+  "src/treemap/renderer.ts"() {
+    "use strict";
+    d3Selection26 = __toESM(require("d3-selection"), 1);
+    import_d3_scale = require("d3-scale");
+    init_fonts();
+    init_colors();
+    init_color_utils();
+    init_tag_groups();
+    init_text_measure();
+    init_legend_integration();
+    init_legend_layout();
+    init_legend_constants();
+    init_title_constants();
+    init_layout16();
+    PADDING3 = 12;
+    HEADER_H = 18;
+    TITLE_BAND = 36;
+    MUTED_FILL = "#cbd5e1";
+    LEAF_MUTE_PCT = 50;
+    LEGEND_POSITION = {
+      placement: "top-center",
+      titleRelation: "below-title"
+    };
+  }
+});
+
+// src/raci/renderer.ts
+var renderer_exports20 = {};
+__export(renderer_exports20, {
   MARKER_LABELS: () => MARKER_LABELS,
   renderRaci: () => renderRaci,
   renderRaciForExport: () => renderRaciForExport
@@ -56642,7 +57461,7 @@ function renderRaci(container, parsed, palette, isDark, handlers, exportDims) {
   const hideLegend = opts.hideLegend ?? false;
   const collapsedPhases = opts.collapsedPhases ?? /* @__PURE__ */ new Set();
   const hideTitle = (opts.hideTitle ?? false) || parsed.options["no-title"] === "on";
-  d3Selection26.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  d3Selection27.select(container).selectAll(":not([data-d3-tooltip])").remove();
   const width = exportDims?.width ?? container.clientWidth;
   const height = exportDims?.height ?? container.clientHeight;
   if (width <= 0 || height <= 0) return;
@@ -56749,7 +57568,7 @@ function renderRaci(container, parsed, palette, isDark, handlers, exportDims) {
   const colBottomY = cursorY + sColumnBottomPad;
   const totalHeight = colBottomY + sVMargin;
   const svgHeight = exportDims ? totalHeight : Math.max(height, totalHeight);
-  const svg = d3Selection26.select(container).append("svg").attr("xmlns", "http://www.w3.org/2000/svg").attr("width", width).attr("height", svgHeight).attr("viewBox", `0 0 ${width} ${svgHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY).style("background", "transparent");
+  const svg = d3Selection27.select(container).append("svg").attr("xmlns", "http://www.w3.org/2000/svg").attr("width", width).attr("height", svgHeight).attr("viewBox", `0 0 ${width} ${svgHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY).style("background", "transparent");
   if (ctx.isBelowFloor) {
     svg.attr("width", "100%");
   }
@@ -57229,15 +58048,15 @@ function parseQuotedSegments(message) {
     out.push({ text: message.slice(last), bold: false });
   return out;
 }
-var d3Selection26, MARKER_LABELS, TITLE_AREA_HEIGHT4, H_MARGIN, V_MARGIN3, LEGEND_HEIGHT2, LEGEND_CHIP_GAP, LEGEND_CHIP_LABEL_MIN, LEGEND_LETTER_CHIP_W, TITLE_LEGEND_GAP, LEGEND_LABEL_FONT, LEGEND_LETTER_FONT, HEADER_HEIGHT5, ROW_HEIGHT, PHASE_HEIGHT, TASK_LABEL_MIN, TASK_LABEL_MAX, ROLE_COL_MIN, ROLE_COL_MAX, CELL_PAD, VIOLATION_LINE_HEIGHT, STACK_TOP_GAP, DESC_FONT, COLUMN_RADIUS3, COLUMN_INSET, COLUMN_BOTTOM_PAD, MARKER_FONT, MARKER_FONT_WEIGHT, LABEL_FONT2, ROLE_HEADER_FONT, PHASE_FONT, TINT_PCT, NODE_RADIUS3, AUTO_ACCENTS, SLICE_GAP, NAME_LINE_HEIGHT, DESC_LINE_HEIGHT9;
-var init_renderer19 = __esm({
+var d3Selection27, MARKER_LABELS, TITLE_AREA_HEIGHT4, H_MARGIN, V_MARGIN3, LEGEND_HEIGHT2, LEGEND_CHIP_GAP, LEGEND_CHIP_LABEL_MIN, LEGEND_LETTER_CHIP_W, TITLE_LEGEND_GAP, LEGEND_LABEL_FONT, LEGEND_LETTER_FONT, HEADER_HEIGHT5, ROW_HEIGHT, PHASE_HEIGHT, TASK_LABEL_MIN, TASK_LABEL_MAX, ROLE_COL_MIN, ROLE_COL_MAX, CELL_PAD, VIOLATION_LINE_HEIGHT, STACK_TOP_GAP, DESC_FONT, COLUMN_RADIUS3, COLUMN_INSET, COLUMN_BOTTOM_PAD, MARKER_FONT, MARKER_FONT_WEIGHT, LABEL_FONT2, ROLE_HEADER_FONT, PHASE_FONT, TINT_PCT, NODE_RADIUS3, AUTO_ACCENTS, SLICE_GAP, NAME_LINE_HEIGHT, DESC_LINE_HEIGHT9;
+var init_renderer20 = __esm({
   "src/raci/renderer.ts"() {
     "use strict";
-    d3Selection26 = __toESM(require("d3-selection"), 1);
+    d3Selection27 = __toESM(require("d3-selection"), 1);
     init_fonts();
     init_title_constants();
     init_color_utils();
-    init_parser26();
+    init_parser27();
     init_variants();
     init_scaling();
     init_text_measure();
@@ -57494,8 +58313,8 @@ var init_tag_resolution = __esm({
 });
 
 // src/sequence/renderer.ts
-var renderer_exports20 = {};
-__export(renderer_exports20, {
+var renderer_exports21 = {};
+__export(renderer_exports21, {
   applyGroupOrdering: () => applyGroupOrdering,
   applyPositionOverrides: () => applyPositionOverrides,
   buildNoteMessageMap: () => buildNoteMessageMap,
@@ -57835,7 +58654,7 @@ function applyGroupOrdering(participants, groups, messages = []) {
   return result;
 }
 function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateToLine, options) {
-  d3Selection27.select(container).selectAll("*").remove();
+  d3Selection28.select(container).selectAll("*").remove();
   const { title, options: parsedOptions } = parsed;
   const solid = parsedOptions["solid-fill"] === "on";
   const effectiveCollapsedGroups = /* @__PURE__ */ new Set();
@@ -58486,7 +59305,7 @@ function renderSequenceDiagram(container, parsed, palette, isDark, _onNavigateTo
     offsetX = leftMargin + Math.max(0, (svgWidth - totalWidth) / 2);
     buildParticipantX();
   }
-  const svg = d3Selection27.select(container).append("svg").attr("width", "100%").attr("height", totalHeight).attr("viewBox", `0 0 ${svgWidth} ${totalHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("class", "sequence-diagram").style("font-family", FONT_FAMILY);
+  const svg = d3Selection28.select(container).append("svg").attr("width", "100%").attr("height", totalHeight).attr("viewBox", `0 0 ${svgWidth} ${totalHeight}`).attr("preserveAspectRatio", "xMidYMin meet").attr("class", "sequence-diagram").style("font-family", FONT_FAMILY);
   const defs = svg.append("defs");
   defs.append("marker").attr("id", "seq-arrowhead").attr("viewBox", `0 0 ${sArrowheadSize} ${sArrowheadSize}`).attr("refX", sArrowheadSize).attr("refY", sArrowheadSize / 2).attr("markerWidth", sArrowheadSize).attr("markerHeight", sArrowheadSize).attr("orient", "auto").append("polygon").attr(
     "points",
@@ -59098,12 +59917,12 @@ function renderParticipant(svg, participant, cx, cy, palette, isDark, color, tag
     });
   }
 }
-var d3Selection27, PARTICIPANT_GAP, PARTICIPANT_BOX_WIDTH, PARTICIPANT_BOX_HEIGHT, LABEL_FONT_SIZE5, TOP_MARGIN, TITLE_HEIGHT8, PARTICIPANT_Y_OFFSET, MESSAGE_START_OFFSET, LIFELINE_TAIL, ARROWHEAD_SIZE, NOTE_MAX_W2, NOTE_FOLD2, NOTE_PAD_H2, NOTE_PAD_V2, NOTE_FONT_SIZE2, NOTE_LINE_H2, NOTE_GAP2, ACTIVATION_WIDTH, SELF_CALL_HEIGHT, SELF_CALL_WIDTH, ACTOR_LABEL_CLEARANCE, labelTextWidth, fill, stroke, SW, W, H;
-var init_renderer20 = __esm({
+var d3Selection28, PARTICIPANT_GAP, PARTICIPANT_BOX_WIDTH, PARTICIPANT_BOX_HEIGHT, LABEL_FONT_SIZE5, TOP_MARGIN, TITLE_HEIGHT8, PARTICIPANT_Y_OFFSET, MESSAGE_START_OFFSET, LIFELINE_TAIL, ARROWHEAD_SIZE, NOTE_MAX_W2, NOTE_FOLD2, NOTE_PAD_H2, NOTE_PAD_V2, NOTE_FONT_SIZE2, NOTE_LINE_H2, NOTE_GAP2, ACTIVATION_WIDTH, SELF_CALL_HEIGHT, SELF_CALL_WIDTH, ACTOR_LABEL_CLEARANCE, labelTextWidth, fill, stroke, SW, W, H;
+var init_renderer21 = __esm({
   "src/sequence/renderer.ts"() {
     "use strict";
     init_tag_groups();
-    d3Selection27 = __toESM(require("d3-selection"), 1);
+    d3Selection28 = __toESM(require("d3-selection"), 1);
     init_color_utils();
     init_inline_markdown();
     init_fonts();
@@ -62992,6 +63811,7 @@ var DIAGRAM_EXPORT_HANDLERS = {
   map: exportMap,
   pyramid: exportPyramid,
   ring: exportRing,
+  treemap: exportTreemap,
   raci: exportRaci,
   rasci: exportRaci,
   daci: exportRaci,
@@ -63049,10 +63869,10 @@ async function exportOrg(ctx) {
     false
     // expandAllLegend off — collapsed-by-default per §1.3
   );
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = effectiveParsed.title ? 30 : 0;
-  const exportWidth = orgLayout.width + PADDING3 * 2;
-  const exportHeight = orgLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = orgLayout.width + PADDING4 * 2;
+  const exportHeight = orgLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   renderOrg2(
     container,
@@ -63094,10 +63914,10 @@ async function exportSitemap(ctx) {
     hiddenAttributes,
     true
   );
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = effectiveParsed.title ? 30 : 0;
-  const exportWidth = sitemapLayout.width + PADDING3 * 2;
-  const exportHeight = sitemapLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = sitemapLayout.width + PADDING4 * 2;
+  const exportHeight = sitemapLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   renderSitemap2(
     container,
@@ -63153,10 +63973,10 @@ async function exportClass(ctx) {
   const classParsed = parseClassDiagram2(content, effectivePalette);
   if (classParsed.error || classParsed.classes.length === 0) return "";
   const classLayout = layoutClassDiagram2(classParsed);
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = classParsed.title ? 40 : 0;
-  const exportWidth = classLayout.width + PADDING3 * 2;
-  const exportHeight = classLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = classLayout.width + PADDING4 * 2;
+  const exportHeight = classLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   renderClassDiagram2(
     container,
@@ -63180,10 +64000,10 @@ async function exportEr(ctx) {
   const erParsed = parseERDiagram2(content, effectivePalette);
   if (erParsed.error || erParsed.tables.length === 0) return "";
   const erLayout = layoutERDiagram2(erParsed);
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = erParsed.title ? 40 : 0;
-  const exportWidth = erLayout.width + PADDING3 * 2;
-  const exportHeight = erLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = erLayout.width + PADDING4 * 2;
+  const exportHeight = erLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   renderERDiagram2(
     container,
@@ -63219,10 +64039,10 @@ async function exportBoxesAndLines(ctx) {
   const { renderBoxesAndLinesForExport: renderBoxesAndLinesForExport2 } = await Promise.resolve().then(() => (init_renderer6(), renderer_exports6));
   const { layoutBoxesAndLines: layoutBoxesAndLines2 } = await Promise.resolve().then(() => (init_layout5(), layout_exports5));
   const blLayout = await layoutBoxesAndLines2(blParsed);
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = blParsed.title ? 40 : 0;
-  const exportWidth = blLayout.width + PADDING3 * 2;
-  const exportHeight = blLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = blLayout.width + PADDING4 * 2;
+  const exportHeight = blLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   const blActiveTagGroup = ctxTagOverride(ctx);
   renderBoxesAndLinesForExport2(
@@ -63269,10 +64089,10 @@ async function exportMindmap(ctx) {
     activeTagGroup,
     hideDescriptions
   });
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = effectiveParsed.title ? 30 : 0;
-  const exportWidth = mmLayout.width + PADDING3 * 2;
-  const exportHeight = mmLayout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = mmLayout.width + PADDING4 * 2;
+  const exportHeight = mmLayout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   const colorByDepth = viewState?.cbd === true;
   renderMindmap2(
@@ -63333,10 +64153,10 @@ async function exportC4(ctx) {
   const c4Container = ctx.options?.c4Container ?? viewState?.c4c;
   const c4Layout = c4Level === "deployment" ? layoutC4Deployment2(c4Parsed) : c4Level === "components" && c4System && c4Container ? layoutC4Components2(c4Parsed, c4System, c4Container) : c4Level === "containers" && c4System ? layoutC4Containers2(c4Parsed, c4System) : layoutC4Context2(c4Parsed);
   if (c4Layout.nodes.length === 0) return "";
-  const PADDING3 = 20;
+  const PADDING4 = 20;
   const titleOffset = c4Parsed.title ? 40 : 0;
-  const exportWidth = c4Layout.width + PADDING3 * 2;
-  const exportHeight = c4Layout.height + PADDING3 * 2 + titleOffset;
+  const exportWidth = c4Layout.width + PADDING4 * 2;
+  const exportHeight = c4Layout.height + PADDING4 * 2 + titleOffset;
   const container = createExportContainer(exportWidth, exportHeight);
   const renderFn = c4Level === "deployment" || c4Level === "components" && c4System && c4Container || c4Level === "containers" && c4System ? renderC4Containers2 : renderC4Context2;
   renderFn(
@@ -63652,30 +64472,44 @@ async function exportRing(ctx) {
   const ringParsed = parseRing2(content);
   if (ringParsed.error || ringParsed.layers.length === 0) return "";
   const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
-  renderRingForExport2(
+  renderRingForExport2(container, ringParsed, effectivePalette, ctx.isDark, {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  });
+  return finalizeSvgExport(container, theme, effectivePalette);
+}
+async function exportTreemap(ctx) {
+  const { content, theme, palette } = ctx;
+  const { parseTreemap: parseTreemap2 } = await Promise.resolve().then(() => (init_parser26(), parser_exports20));
+  const { renderTreemapForExport: renderTreemapForExport2 } = await Promise.resolve().then(() => (init_renderer19(), renderer_exports19));
+  const effectivePalette = await resolveExportPalette(theme, palette);
+  const treemapParsed = parseTreemap2(content, effectivePalette);
+  if (treemapParsed.error || treemapParsed.roots.length === 0) return "";
+  const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
+  renderTreemapForExport2(
     container,
-    ringParsed,
+    treemapParsed,
     effectivePalette,
     ctx.isDark,
-    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
+    {
+      width: EXPORT_WIDTH,
+      height: EXPORT_HEIGHT
+    }
   );
   return finalizeSvgExport(container, theme, effectivePalette);
 }
 async function exportRaci(ctx) {
   const { content, theme, palette } = ctx;
-  const { parseRaci: parseRaci2 } = await Promise.resolve().then(() => (init_parser26(), parser_exports20));
-  const { renderRaciForExport: renderRaciForExport2 } = await Promise.resolve().then(() => (init_renderer19(), renderer_exports19));
+  const { parseRaci: parseRaci2 } = await Promise.resolve().then(() => (init_parser27(), parser_exports21));
+  const { renderRaciForExport: renderRaciForExport2 } = await Promise.resolve().then(() => (init_renderer20(), renderer_exports20));
   const effectivePalette = await resolveExportPalette(theme, palette);
   const raciParsed = parseRaci2(content, effectivePalette);
   if (raciParsed.error) return "";
   const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
-  renderRaciForExport2(
-    container,
-    raciParsed,
-    effectivePalette,
-    ctx.isDark,
-    { width: EXPORT_WIDTH, height: EXPORT_HEIGHT }
-  );
+  renderRaciForExport2(container, raciParsed, effectivePalette, ctx.isDark, {
+    width: EXPORT_WIDTH,
+    height: EXPORT_HEIGHT
+  });
   return finalizeSvgExport(container, theme, effectivePalette);
 }
 function beginVizExport() {
@@ -63764,14 +64598,7 @@ async function exportVenn(ctx) {
   if (parsed.error || parsed.vennSets.length < 2) return "";
   const effectivePalette = await resolveExportPalette(theme, palette);
   const { container, dims } = beginVizExport();
-  renderVenn(
-    container,
-    parsed,
-    effectivePalette,
-    ctx.isDark,
-    void 0,
-    dims
-  );
+  renderVenn(container, parsed, effectivePalette, ctx.isDark, void 0, dims);
   return finalizeSvgExport(container, theme, effectivePalette);
 }
 async function exportQuadrant(ctx) {
@@ -63805,7 +64632,7 @@ async function exportVisualization(ctx) {
   const isDark = ctx.isDark;
   const container = createExportContainer(EXPORT_WIDTH, EXPORT_HEIGHT);
   const { parseSequenceDgmo: parseSequenceDgmo2 } = await Promise.resolve().then(() => (init_parser7(), parser_exports));
-  const { renderSequenceDiagram: renderSequenceDiagram2 } = await Promise.resolve().then(() => (init_renderer20(), renderer_exports20));
+  const { renderSequenceDiagram: renderSequenceDiagram2 } = await Promise.resolve().then(() => (init_renderer21(), renderer_exports21));
   const seqParsed = parseSequenceDgmo2(content, effectivePalette);
   if (seqParsed.error || seqParsed.participants.length === 0) return "";
   const collapsedSections = viewState?.cs ? new Set(viewState.cs) : void 0;
@@ -64016,6 +64843,7 @@ var CHART_TYPES = /* @__PURE__ */ new Set([
   "journey-map",
   "pyramid",
   "ring",
+  "treemap",
   "raci",
   "rasci",
   "daci",
@@ -64207,6 +65035,8 @@ var ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
   "value",
   "label",
   "style",
+  // Treemap color-by-value metric key
+  "heat",
   // Infra node behavior + edge colon-keys (§4) come from the single-source
   // directives registry — the parser accepts them only as `key: value` node
   // properties, so they render as `propertyName`. The dual-use top-level SLO
@@ -64584,7 +65414,7 @@ pre.dgmo, code.language-dgmo, pre > code.language-dgmo,
 
 // src/auto/index.ts
 init_safe_href();
-var VERSION = "0.37.0";
+var VERSION = "0.38.0";
 var DEFAULTS = {
   theme: "auto",
   palette: "slate",