@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-CI2G3OEB.js

@@ -0,0 +1,1818 @@
+import {
+  computeNodeSizing,
+  layoutPert
+} from "./chunk-4OHACBGX.js";
+import {
+  analyzePert
+} from "./chunk-NX4EQS3U.js";
+import {
+  COLLAPSE_BAR_HEIGHT,
+  CONTAINER_HEADER_HEIGHT,
+  CONTAINER_LABEL_FONT_SIZE,
+  CONTAINER_RADIUS,
+  EDGE_STROKE_WIDTH,
+  NODE_STROKE_WIDTH
+} from "./chunk-3CIOJ5YJ.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  CAPTION_BOX_PADDING_X,
+  CAPTION_BOX_PADDING_Y,
+  CAPTION_FONT_SIZE,
+  CAPTION_FONT_WEIGHT,
+  CAPTION_LINE_HEIGHT,
+  CAPTION_TOP_GAP,
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  LEGEND_HEIGHT
+} from "./chunk-QOOUC2J5.js";
+import {
+  measureText,
+  truncateText,
+  wrapTextToWidth
+} from "./chunk-WCT3NYCV.js";
+import {
+  parsePert
+} from "./chunk-RTLBSQ3G.js";
+import {
+  addCalendarDays,
+  formatDuration,
+  formatScheduleValue,
+  formatSlackValue,
+  formatSprintCell
+} from "./chunk-L3UHP6TD.js";
+import {
+  contrastText,
+  mix,
+  shapeFill,
+  themeBaseBg
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveActiveTagGroup,
+  resolveTagColor
+} from "./chunk-QLCCJEJI.js";
+
+// src/pert/renderer.ts
+import * as d3Selection from "d3-selection";
+import * as d3Shape from "d3-shape";
+var DIAGRAM_PADDING = 20;
+var NODE_FONT_SIZE = 13;
+var NODE_CELL_FONT_SIZE = 11;
+var NODE_RADIUS = 6;
+function analysisBlockChrome(palette, isDark) {
+  const surfaceBg = themeBaseBg(palette, isDark);
+  return {
+    fill: mix(palette.surface, palette.bg, 40),
+    stroke: mix(palette.textMuted, surfaceBg, 35)
+  };
+}
+var NODE_TOP_ROW_HEIGHT = 26;
+var NODE_BOTTOM_ROW_HEIGHT = 26;
+var ARROWHEAD_W = 10;
+var ARROWHEAD_H = 7;
+var DURATION_FADE_OPACITY = 0.55;
+var PIN_ICON_W = 13;
+var PIN_ICON_H = 13;
+var LEGEND_PILL_HEIGHT = LEGEND_HEIGHT;
+var LEGEND_TOP_GAP = 12;
+var LEGEND_BOTTOM_GAP = 12;
+var FIELD_LEGEND_HEADER_BAND_HEIGHT = 26;
+var FIELD_LEGEND_CELL_VPAD = 14;
+function fieldLegendRowHeight(maxDescLines) {
+  return FIELD_LEGEND_CELL_VPAD * 2 + FIELD_LEGEND_LABEL_FONT_SIZE + FIELD_LEGEND_LABEL_DESC_GAP + maxDescLines * FIELD_LEGEND_DESC_LINE_HEIGHT;
+}
+function fieldLegendDescWidth(colW) {
+  return colW - 8;
+}
+function fieldLegendHeightFor(width) {
+  const colW = width / 3;
+  const wrapW = fieldLegendDescWidth(colW);
+  let maxLines = 1;
+  for (const cell of FIELD_LEGEND_CELLS) {
+    const n = wrapTextToWidth(
+      cell.desc,
+      FIELD_LEGEND_DESC_FONT_SIZE,
+      wrapW
+    ).length;
+    if (n > maxLines) maxLines = n;
+  }
+  return FIELD_LEGEND_HEADER_BAND_HEIGHT + fieldLegendRowHeight(maxLines) * 2 + CAPTION_BOX_PADDING_Y;
+}
+var FIELD_LEGEND_LABEL_FONT_SIZE = 13;
+var FIELD_LEGEND_DESC_FONT_SIZE = 13;
+var FIELD_LEGEND_DESC_LINE_HEIGHT = 17;
+var FIELD_LEGEND_LABEL_DESC_GAP = 4;
+var FIELD_LEGEND_CELLS = [
+  {
+    label: "Early Start",
+    desc: "earliest this activity can begin once predecessors finish"
+  },
+  {
+    label: "Duration",
+    desc: "expected time needed to complete the work"
+  },
+  {
+    label: "Early Finish",
+    desc: "earliest this activity can be fully completed"
+  },
+  {
+    label: "Late Start",
+    desc: "latest this activity can begin without delaying the project"
+  },
+  {
+    label: "Slack",
+    desc: "extra time before this activity's delay pushes the deadline"
+  },
+  {
+    label: "Late Finish",
+    desc: "latest this activity can finish without delaying the project"
+  }
+];
+var lineGenerator = d3Shape.line().x((d) => d.x).y((d) => d.y).curve(d3Shape.curveBasis);
+function criticalityBand(c) {
+  if (c === null) return null;
+  if (c >= 0.8) return "red";
+  if (c >= 0.5) return "orange";
+  if (c >= 0.25) return "yellow";
+  if (c >= 0.1) return "green";
+  if (c >= 0.02) return "blue";
+  return null;
+}
+function bandColor(band, palette, fallback) {
+  return band === null ? fallback : palette.colors[band];
+}
+function bandArrow(band) {
+  return band === null ? "pert-arrow" : `pert-arrow-${band}`;
+}
+function renderPert(container, resolved, layout, palette, isDark, options = {}) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const effectiveTitle = options.title;
+  const effectiveSubtitle = options.subtitle ?? null;
+  const titleHeight = effectiveTitle ? 80 : effectiveSubtitle ? 50 : 0;
+  const anchorAnnotation = anchorAnnotationText(resolved);
+  const collapsedSet = new Set(options.collapsedGroupIds ?? []);
+  const captionRows = resolved.error !== null ? null : resolved.summaryRows;
+  const captionBullets = captionRows !== null && captionRows.length > 0 ? bulletizeCaption(captionRows) : [];
+  if (anchorAnnotation) {
+    captionBullets.push({
+      text: anchorAnnotation,
+      level: 0,
+      italic: true
+    });
+  }
+  const analysisLayer = computeAnalysisLayer(resolved, captionBullets, {
+    showSummary: options.showSummary ?? true,
+    showTornado: options.showTornado ?? false,
+    showScurve: options.showScurve ?? false,
+    showFieldLegend: options.showFieldLegend ?? false
+  });
+  const standaloneFieldLegendWidthForExport = layout.width;
+  const analysisBlockHeight = analysisLayer.analysisHasContent ? CAPTION_TOP_GAP + analysisLayer.analysisRowHeight : 0;
+  const fieldLegendBlockHeight = analysisLayer.fieldLegendStandalone ? CAPTION_TOP_GAP + fieldLegendHeightFor(standaloneFieldLegendWidthForExport) : 0;
+  const showLegend = options.showLegend ?? true;
+  const tagLegendActive = resolveActiveTagGroup(
+    resolved.tagGroups,
+    resolved.options.activeTag,
+    options.activeTagOverride
+  );
+  const showTagLegend = showLegend && resolved.tagGroups.length > 0;
+  const legendBlockHeight = showTagLegend ? LEGEND_TOP_GAP + LEGEND_PILL_HEIGHT + LEGEND_BOTTOM_GAP : 0;
+  const naturalChartWidth = layout.width + DIAGRAM_PADDING * 2;
+  const minAnalysisRowW = analysisLayer.analysisHasContent ? analysisLayer.minContentWidth + 2 * DIAGRAM_PADDING : 0;
+  const naturalWidth = Math.max(naturalChartWidth, minAnalysisRowW);
+  const naturalHeight = layout.height + DIAGRAM_PADDING * 2 + titleHeight + legendBlockHeight + analysisBlockHeight + fieldLegendBlockHeight;
+  const exportWidth = Math.max(
+    options.exportDims?.width ?? naturalWidth,
+    naturalWidth
+  );
+  const exportHeight = Math.max(
+    options.exportDims?.height ?? naturalHeight,
+    naturalHeight
+  );
+  if (exportWidth <= 0 || exportHeight <= 0) return;
+  const ctx = options.exportDims ? ScaleContext.identity() : options.containerWidth != null ? ScaleContext.from(options.containerWidth, naturalWidth) : ScaleContext.identity();
+  const sDiagramPad = ctx.aesthetic(DIAGRAM_PADDING);
+  const sTitleHeight = ctx.aesthetic(titleHeight);
+  const sTitleFontSize = ctx.text(TITLE_FONT_SIZE);
+  const sTitleY = ctx.aesthetic(TITLE_Y);
+  const sSubtitleFontSize = ctx.text(13);
+  const sLegendTopGap = ctx.aesthetic(LEGEND_TOP_GAP);
+  const sLegendBottomGap = ctx.aesthetic(LEGEND_BOTTOM_GAP);
+  const sLegendPillHeight = ctx.structural(LEGEND_PILL_HEIGHT);
+  const sLegendBlockHeight = showTagLegend ? sLegendTopGap + sLegendPillHeight + sLegendBottomGap : 0;
+  const sNodeRadius = ctx.structural(NODE_RADIUS);
+  const sNodeStrokeWidth = ctx.structural(NODE_STROKE_WIDTH);
+  const sNodeFontSize = ctx.text(NODE_FONT_SIZE);
+  const sNodeCellFontSize = ctx.text(NODE_CELL_FONT_SIZE);
+  const sNodeTopRowHeight = ctx.structural(NODE_TOP_ROW_HEIGHT);
+  const sNodeBottomRowHeight = ctx.structural(NODE_BOTTOM_ROW_HEIGHT);
+  const sEdgeStrokeWidth = ctx.structural(EDGE_STROKE_WIDTH);
+  const sArrowheadW = ctx.structural(ARROWHEAD_W);
+  const sArrowheadH = ctx.structural(ARROWHEAD_H);
+  const sContainerRadius = ctx.structural(CONTAINER_RADIUS);
+  const sContainerLabelFontSize = ctx.text(CONTAINER_LABEL_FONT_SIZE);
+  const sContainerHeaderHeight = ctx.structural(CONTAINER_HEADER_HEIGHT);
+  const sCollapseBarHeight = ctx.structural(COLLAPSE_BAR_HEIGHT);
+  const sPinIconW = ctx.structural(PIN_ICON_W);
+  const sPinIconH = ctx.structural(PIN_ICON_H);
+  const scaledWidth = layout.width + sDiagramPad * 2;
+  const scaledHeight = layout.height + sDiagramPad * 2 + sTitleHeight + sLegendBlockHeight + analysisBlockHeight + fieldLegendBlockHeight;
+  const svgW = ctx.isBelowFloor ? exportWidth : scaledWidth;
+  const svgH = ctx.isBelowFloor ? exportHeight : scaledHeight;
+  const svg = d3Selection.select(container).append("svg").attr("width", ctx.isBelowFloor ? "100%" : svgW).attr("height", svgH).attr("viewBox", `0 0 ${svgW} ${svgH}`).attr("preserveAspectRatio", "xMidYMin meet").style("font-family", FONT_FAMILY);
+  const defs = svg.append("defs");
+  buildArrowheads(defs, palette, sArrowheadW, sArrowheadH);
+  if (effectiveTitle) {
+    svg.append("text").attr("class", "pert-title chart-title").attr("x", svgW / 2).attr("y", sTitleY).attr("text-anchor", "middle").attr("fill", palette.text).attr("font-size", sTitleFontSize).attr("font-weight", TITLE_FONT_WEIGHT).text(effectiveTitle);
+  }
+  if (effectiveSubtitle) {
+    const subtitleY = effectiveTitle ? sTitleY + ctx.aesthetic(26) : sTitleY;
+    svg.append("text").attr("class", "pert-subtitle").attr("x", svgW / 2).attr("y", subtitleY).attr("text-anchor", "middle").attr("fill", palette.textMuted).attr("font-size", sSubtitleFontSize).attr("font-weight", 400).text(effectiveSubtitle);
+  }
+  const offsetX = Math.max(sDiagramPad, (svgW - layout.width) / 2);
+  const offsetY = sDiagramPad + sTitleHeight + sLegendBlockHeight;
+  if (showTagLegend) {
+    const tagLegendY = sDiagramPad + sTitleHeight + sLegendTopGap;
+    renderTagLegendRow(svg, resolved, palette, isDark, {
+      x: 0,
+      y: tagLegendY,
+      width: svgW,
+      activeGroup: tagLegendActive,
+      ...options.exportMode !== void 0 && {
+        exportMode: options.exportMode
+      }
+    });
+  }
+  const root = svg.append("g").attr("transform", `translate(${offsetX}, ${offsetY})`);
+  const sizing = computeNodeSizing(resolved);
+  renderGroups(root, resolved, layout, palette, isDark, collapsedSet, sizing, {
+    nodeRadius: sNodeRadius,
+    nodeStrokeWidth: sNodeStrokeWidth,
+    containerRadius: sContainerRadius,
+    containerLabelFontSize: sContainerLabelFontSize,
+    containerHeaderHeight: sContainerHeaderHeight,
+    collapseBarHeight: sCollapseBarHeight,
+    nodeTopRowHeight: sNodeTopRowHeight,
+    nodeBottomRowHeight: sNodeBottomRowHeight,
+    nodeFontSize: sNodeFontSize,
+    nodeCellFontSize: sNodeCellFontSize,
+    pinIconW: sPinIconW,
+    pinIconH: sPinIconH
+  });
+  renderEdges(root, resolved, layout, palette, collapsedSet, {
+    edgeStrokeWidth: sEdgeStrokeWidth,
+    edgeLabelFontSize: ctx.text(10)
+  });
+  renderNodes(
+    root,
+    defs,
+    resolved,
+    layout,
+    palette,
+    isDark,
+    sizing,
+    options.onClickItem,
+    collapsedSet,
+    options.activeTagOverride,
+    {
+      nodeRadius: sNodeRadius,
+      nodeStrokeWidth: sNodeStrokeWidth,
+      nodeTopRowHeight: sNodeTopRowHeight,
+      nodeBottomRowHeight: sNodeBottomRowHeight,
+      nodeFontSize: sNodeFontSize,
+      nodeCellFontSize: sNodeCellFontSize,
+      pinIconW: sPinIconW,
+      pinIconH: sPinIconH
+    }
+  );
+  paintAnalysisLayer(
+    svg,
+    resolved,
+    palette,
+    isDark,
+    analysisLayer,
+    captionBullets,
+    sDiagramPad,
+    offsetY + layout.height,
+    svgW - 2 * sDiagramPad
+  );
+}
+function renderPertForExport(content, theme, palette, now) {
+  const parsed = parsePert(content, {
+    ...now !== void 0 && { now },
+    palette
+  });
+  if (parsed.error || parsed.activities.length === 0) return "";
+  const resolved = analyzePert(parsed);
+  const layout = layoutPert(resolved);
+  const isDark = theme === "dark";
+  const hasTitle = !!parsed.title && !resolved.options.noTitle;
+  const hasSubtitle = resolved.projectSubtitle !== null;
+  const titleHeight = hasTitle ? 80 : hasSubtitle ? 50 : 0;
+  const captionBullets = resolved.summaryRows !== null && resolved.summaryRows.length > 0 ? bulletizeCaption(resolved.summaryRows) : [];
+  const anchorNote = anchorAnnotationText(resolved);
+  if (anchorNote) {
+    captionBullets.push({ text: anchorNote, level: 0, italic: true });
+  }
+  const captionBoxHeight = captionBullets.length > 0 ? captionBullets.length * CAPTION_LINE_HEIGHT + 2 * CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT : 0;
+  const captionBlockHeight = captionBullets.length > 0 ? CAPTION_TOP_GAP + captionBoxHeight : 0;
+  const legendBlockHeight = resolved.tagGroups.length > 0 ? LEGEND_TOP_GAP + LEGEND_PILL_HEIGHT + LEGEND_BOTTOM_GAP : 0;
+  const exportWidth = layout.width + DIAGRAM_PADDING * 2;
+  const exportHeight = layout.height + DIAGRAM_PADDING * 2 + titleHeight + legendBlockHeight + captionBlockHeight;
+  const container = document.createElement("div");
+  container.style.width = `${exportWidth}px`;
+  container.style.height = `${exportHeight}px`;
+  container.style.position = "absolute";
+  container.style.left = "-9999px";
+  document.body.appendChild(container);
+  try {
+    renderPert(container, resolved, layout, palette, isDark, {
+      title: hasTitle ? parsed.title : null,
+      subtitle: resolved.projectSubtitle,
+      exportDims: { width: exportWidth, height: exportHeight },
+      exportMode: true
+    });
+    const svgEl = container.querySelector("svg");
+    if (!svgEl) return "";
+    if (theme === "transparent") svgEl.style.background = "none";
+    else svgEl.style.background = palette.bg;
+    svgEl.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    svgEl.style.fontFamily = FONT_FAMILY;
+    return svgEl.outerHTML;
+  } finally {
+    document.body.removeChild(container);
+  }
+}
+function computeAnalysisLayer(resolved, captionBullets, opts) {
+  const summaryRendered = opts.showSummary && captionBullets.length > 0;
+  const captionBoxHeight = summaryRendered ? captionBullets.length * CAPTION_LINE_HEIGHT + 2 * CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT : 0;
+  let tornadoRows = opts.showTornado ? buildTornadoRows(resolved) : [];
+  const showTornado = tornadoRows.length > 0;
+  let tornadoBoxHeight = showTornado ? tornadoBoxHeightFor(tornadoRows) : 0;
+  const scurveData = opts.showScurve ? buildScurveData(resolved) : null;
+  const showScurve = scurveData !== null;
+  const scurveBoxHeight = showScurve ? SCURVE_BOX_HEIGHT : 0;
+  const fieldLegendInAnalysisRow = opts.showFieldLegend && (summaryRendered || showTornado || showScurve);
+  const col1Width = summaryRendered ? Math.max(
+    SUMMARY_MIN_W,
+    Math.min(SUMMARY_MAX_W, captionNaturalWidth(captionBullets))
+  ) : fieldLegendInAnalysisRow ? SUMMARY_MAX_W : 0;
+  const fieldLegendCol1Height = fieldLegendInAnalysisRow ? fieldLegendHeightFor(col1Width) : 0;
+  const col1Items = [];
+  if (summaryRendered) col1Items.push(captionBoxHeight);
+  if (fieldLegendInAnalysisRow) col1Items.push(fieldLegendCol1Height);
+  const col1Height = col1Items.length ? col1Items.reduce((a, b) => a + b, 0) + (col1Items.length - 1) * COL1_VSTACK_GAP : 0;
+  let analysisRowHeight = Math.max(
+    col1Height,
+    scurveBoxHeight,
+    tornadoBoxHeight
+  );
+  if (showTornado) {
+    const maxRows = tornadoMaxRowsFor(analysisRowHeight);
+    if (maxRows > tornadoRows.length) {
+      tornadoRows = buildTornadoRows(resolved, maxRows);
+      tornadoBoxHeight = tornadoBoxHeightFor(tornadoRows);
+      analysisRowHeight = Math.max(
+        col1Height,
+        scurveBoxHeight,
+        tornadoBoxHeight
+      );
+    }
+  }
+  const analysisCharts = [];
+  if (showTornado)
+    analysisCharts.push({ kind: "tornado", contentHeight: tornadoBoxHeight });
+  if (showScurve)
+    analysisCharts.push({ kind: "scurve", contentHeight: scurveBoxHeight });
+  const analysisHasContent = summaryRendered || analysisCharts.length > 0 || fieldLegendInAnalysisRow;
+  const fieldLegendStandalone = opts.showFieldLegend && !fieldLegendInAnalysisRow;
+  let minContentWidth = 0;
+  if (analysisHasContent) {
+    const col1Used = summaryRendered || fieldLegendInAnalysisRow;
+    if (col1Used) minContentWidth += col1Width;
+    for (const w of analysisCharts) {
+      minContentWidth += w.kind === "tornado" ? TORNADO_MIN_W : SCURVE_MIN_W;
+    }
+    const colCount = (col1Used ? 1 : 0) + analysisCharts.length;
+    if (colCount > 1) minContentWidth += (colCount - 1) * ANALYSIS_GAP;
+  }
+  return {
+    summaryRendered,
+    showTornado,
+    showScurve,
+    fieldLegendInAnalysisRow,
+    fieldLegendStandalone,
+    analysisHasContent,
+    tornadoRows,
+    scurveData,
+    analysisCharts,
+    captionBoxHeight,
+    fieldLegendCol1Height,
+    tornadoBoxHeight,
+    scurveBoxHeight,
+    col1Width,
+    col1Height,
+    analysisRowHeight,
+    minContentWidth
+  };
+}
+function analysisLayerHeightAt(state, availableWidth) {
+  if (!state.analysisHasContent) {
+    return state.fieldLegendStandalone ? CAPTION_TOP_GAP + fieldLegendHeightFor(availableWidth) : 0;
+  }
+  if (availableWidth >= state.minContentWidth) {
+    return CAPTION_TOP_GAP + state.analysisRowHeight;
+  }
+  const rows = packRows(state, availableWidth);
+  let total = 0;
+  rows.forEach((row, i) => {
+    let rowHeight = 0;
+    for (const item of row) {
+      rowHeight = Math.max(
+        rowHeight,
+        itemContentHeight(state, item.kind, item.paintWidth)
+      );
+    }
+    total += rowHeight;
+    if (i < rows.length - 1) total += ANALYSIS_GAP;
+  });
+  return CAPTION_TOP_GAP + total;
+}
+function paintAnalysisLayer(svg, resolved, palette, isDark, state, captionBullets, x, y, availableWidth) {
+  if (!state.analysisHasContent) {
+    if (!state.fieldLegendStandalone) return 0;
+    const bandY = y + CAPTION_TOP_GAP;
+    const h = fieldLegendHeightFor(availableWidth);
+    renderFieldLegendBlock(svg, {
+      x,
+      y: bandY,
+      width: availableWidth,
+      height: h,
+      palette,
+      isDark
+    });
+    return CAPTION_TOP_GAP + h;
+  }
+  if (availableWidth >= state.minContentWidth) {
+    return paintAnalysisRowMode(
+      svg,
+      resolved,
+      palette,
+      isDark,
+      state,
+      captionBullets,
+      x,
+      y,
+      availableWidth
+    );
+  }
+  return paintAnalysisStackMode(
+    svg,
+    resolved,
+    palette,
+    isDark,
+    state,
+    captionBullets,
+    x,
+    y,
+    availableWidth
+  );
+}
+function paintAnalysisRowMode(svg, resolved, palette, isDark, state, captionBullets, x, y, availableWidth) {
+  const bandY = y + CAPTION_TOP_GAP;
+  const col1Used = state.summaryRendered || state.fieldLegendInAnalysisRow;
+  const colCount = (col1Used ? 1 : 0) + state.analysisCharts.length;
+  const nGaps = Math.max(0, colCount - 1);
+  const usableWidth = availableWidth - nGaps * ANALYSIS_GAP;
+  const chartWidth = state.analysisCharts.length > 0 ? (usableWidth - state.col1Width) / state.analysisCharts.length : 0;
+  let cursorX = x;
+  for (const w of state.analysisCharts) {
+    const args = {
+      x: cursorX,
+      y: bandY,
+      width: chartWidth,
+      height: state.analysisRowHeight,
+      palette,
+      isDark
+    };
+    if (w.kind === "tornado") {
+      renderTornadoBlock(svg, state.tornadoRows, args);
+    } else {
+      const scurveTitle = !state.summaryRendered && captionBullets.length > 0 ? (
+        // In-bounds by length check.
+        captionBullets[0].text
+      ) : void 0;
+      renderScurveBlock(svg, state.scurveData, {
+        ...args,
+        unit: resolved.options.timeUnit,
+        ...scurveTitle !== void 0 && { title: scurveTitle }
+      });
+    }
+    cursorX += chartWidth + ANALYSIS_GAP;
+  }
+  if (col1Used) {
+    let stackY = bandY;
+    if (state.summaryRendered) {
+      renderCaptionBlock(svg, captionBullets, {
+        x: cursorX,
+        y: stackY,
+        width: state.col1Width,
+        height: state.captionBoxHeight,
+        palette,
+        isDark
+      });
+      stackY += state.captionBoxHeight + COL1_VSTACK_GAP;
+    }
+    if (state.fieldLegendInAnalysisRow) {
+      renderFieldLegendBlock(svg, {
+        x: cursorX,
+        y: stackY,
+        width: state.col1Width,
+        height: state.fieldLegendCol1Height,
+        palette,
+        isDark
+      });
+    }
+  }
+  return CAPTION_TOP_GAP + state.analysisRowHeight;
+}
+var FIELD_LEGEND_MIN_W = 220;
+function packRows(state, availableWidth) {
+  const rows = [];
+  const charts = state.analysisCharts;
+  if (charts.length === 2) {
+    const minTwo = (charts[0].kind === "tornado" ? TORNADO_MIN_W : SCURVE_MIN_W) + ANALYSIS_GAP + (charts[1].kind === "tornado" ? TORNADO_MIN_W : SCURVE_MIN_W);
+    if (availableWidth >= minTwo) {
+      const itemW = (availableWidth - ANALYSIS_GAP) / 2;
+      rows.push([
+        { kind: charts[0].kind, paintWidth: itemW },
+        { kind: charts[1].kind, paintWidth: itemW }
+      ]);
+    } else {
+      for (const c of charts) {
+        rows.push([{ kind: c.kind, paintWidth: availableWidth }]);
+      }
+    }
+  } else if (charts.length === 1) {
+    rows.push([{ kind: charts[0].kind, paintWidth: availableWidth }]);
+  }
+  const hasSummary = state.summaryRendered;
+  const hasField = state.fieldLegendInAnalysisRow;
+  if (hasSummary && hasField) {
+    const summaryW = state.col1Width;
+    const fieldW = availableWidth - summaryW - ANALYSIS_GAP;
+    if (fieldW >= FIELD_LEGEND_MIN_W) {
+      rows.push([
+        { kind: "summary", paintWidth: summaryW },
+        { kind: "field", paintWidth: fieldW }
+      ]);
+    } else {
+      rows.push([{ kind: "summary", paintWidth: summaryW }]);
+      rows.push([{ kind: "field", paintWidth: availableWidth }]);
+    }
+  } else if (hasSummary) {
+    rows.push([{ kind: "summary", paintWidth: state.col1Width }]);
+  } else if (hasField) {
+    rows.push([{ kind: "field", paintWidth: availableWidth }]);
+  }
+  return rows;
+}
+function itemContentHeight(state, kind, paintWidth) {
+  switch (kind) {
+    case "tornado":
+      return state.tornadoBoxHeight;
+    case "scurve":
+      return state.scurveBoxHeight;
+    case "summary":
+      return state.captionBoxHeight;
+    case "field":
+      return fieldLegendHeightFor(paintWidth);
+  }
+}
+function paintAnalysisStackMode(svg, resolved, palette, isDark, state, captionBullets, x, y, availableWidth) {
+  const rows = packRows(state, availableWidth);
+  let cursorY = y + CAPTION_TOP_GAP;
+  rows.forEach((row, rowIndex) => {
+    const gaps = Math.max(0, row.length - 1) * ANALYSIS_GAP;
+    const totalRowW = row.reduce((a, it) => a + it.paintWidth, 0) + gaps;
+    const rowOffset = Math.max(0, (availableWidth - totalRowW) / 2);
+    let rowHeight = 0;
+    for (const item of row) {
+      rowHeight = Math.max(
+        rowHeight,
+        itemContentHeight(state, item.kind, item.paintWidth)
+      );
+    }
+    let cursorX = x + rowOffset;
+    for (const item of row) {
+      const args = {
+        x: cursorX,
+        y: cursorY,
+        width: item.paintWidth,
+        height: rowHeight,
+        palette,
+        isDark
+      };
+      switch (item.kind) {
+        case "tornado":
+          renderTornadoBlock(svg, state.tornadoRows, args);
+          break;
+        case "scurve": {
+          const scurveTitle = !state.summaryRendered && captionBullets.length > 0 ? (
+            // In-bounds by length check.
+            captionBullets[0].text
+          ) : void 0;
+          renderScurveBlock(svg, state.scurveData, {
+            ...args,
+            unit: resolved.options.timeUnit,
+            ...scurveTitle !== void 0 && { title: scurveTitle }
+          });
+          break;
+        }
+        case "summary":
+          renderCaptionBlock(svg, captionBullets, args);
+          break;
+        case "field":
+          renderFieldLegendBlock(svg, args);
+          break;
+      }
+      cursorX += item.paintWidth + ANALYSIS_GAP;
+    }
+    cursorY += rowHeight;
+    if (rowIndex < rows.length - 1) cursorY += ANALYSIS_GAP;
+  });
+  return cursorY - y;
+}
+function measurePertAnalysisBlock(resolved, width, options) {
+  const captionRows = resolved.error !== null ? null : resolved.summaryRows;
+  const captionBullets = captionRows !== null && captionRows.length > 0 ? bulletizeCaption(captionRows) : [];
+  const anchorAnnotation = anchorAnnotationText(resolved);
+  if (anchorAnnotation) {
+    captionBullets.push({ text: anchorAnnotation, level: 0, italic: true });
+  }
+  const state = computeAnalysisLayer(resolved, captionBullets, {
+    showSummary: options.showSummary ?? true,
+    showTornado: options.showTornado ?? false,
+    showScurve: options.showScurve ?? false,
+    showFieldLegend: options.showFieldLegend ?? false
+  });
+  if (!state.analysisHasContent && !state.fieldLegendStandalone) {
+    return { width: 0, height: 0 };
+  }
+  const itemMinW = Math.max(
+    state.summaryRendered ? SUMMARY_MIN_W : 0,
+    state.showTornado ? TORNADO_MIN_W : 0,
+    state.showScurve ? SCURVE_MIN_W : 0,
+    0
+  );
+  const w = Math.max(width, itemMinW);
+  return { width: w, height: analysisLayerHeightAt(state, w) };
+}
+function renderPertAnalysisBlock(container, resolved, palette, isDark, options) {
+  d3Selection.select(container).selectAll(":not([data-d3-tooltip])").remove();
+  const captionRows = resolved.error !== null ? null : resolved.summaryRows;
+  const captionBullets = captionRows !== null && captionRows.length > 0 ? bulletizeCaption(captionRows) : [];
+  const anchorAnnotation = anchorAnnotationText(resolved);
+  if (anchorAnnotation) {
+    captionBullets.push({ text: anchorAnnotation, level: 0, italic: true });
+  }
+  const state = computeAnalysisLayer(resolved, captionBullets, {
+    showSummary: options.showSummary ?? true,
+    showTornado: options.showTornado ?? false,
+    showScurve: options.showScurve ?? false,
+    showFieldLegend: options.showFieldLegend ?? false
+  });
+  if (!state.analysisHasContent && !state.fieldLegendStandalone) return;
+  const itemMinW = Math.max(
+    state.summaryRendered ? SUMMARY_MIN_W : 0,
+    state.showTornado ? TORNADO_MIN_W : 0,
+    state.showScurve ? SCURVE_MIN_W : 0,
+    // Field labels has no hard min — it wraps to whatever width it gets.
+    0
+  );
+  const width = Math.max(options.width, itemMinW);
+  const totalHeight = analysisLayerHeightAt(state, width);
+  if (totalHeight <= 0 || width <= 0) return;
+  const svg = d3Selection.select(container).append("svg").attr("width", width).attr("height", totalHeight).attr("viewBox", `0 0 ${width} ${totalHeight}`).attr("preserveAspectRatio", "xMidYMin meet").style("font-family", FONT_FAMILY).style("overflow", "visible");
+  paintAnalysisLayer(
+    svg,
+    resolved,
+    palette,
+    isDark,
+    state,
+    captionBullets,
+    0,
+    0,
+    width
+  );
+}
+function buildArrowheads(defs, palette, arrowW = ARROWHEAD_W, arrowH = ARROWHEAD_H) {
+  const mk = (id, fill) => {
+    defs.append("marker").attr("id", id).attr("viewBox", `0 0 ${arrowW} ${arrowH}`).attr("refX", arrowW).attr("refY", arrowH / 2).attr("markerWidth", arrowW).attr("markerHeight", arrowH).attr("orient", "auto").append("polygon").attr("points", `0,0 ${arrowW},${arrowH / 2} 0,${arrowH}`).attr("fill", fill);
+  };
+  mk("pert-arrow", palette.textMuted);
+  mk("pert-arrow-red", palette.colors.red);
+  mk("pert-arrow-orange", palette.colors.orange);
+  mk("pert-arrow-yellow", palette.colors.yellow);
+  mk("pert-arrow-green", palette.colors.green);
+  mk("pert-arrow-blue", palette.colors.blue);
+}
+function renderGroups(root, resolved, layout, palette, isDark, collapsedSet, sizing, sc = {}) {
+  if (layout.groups.length === 0) return;
+  const layer = root.append("g").attr("class", "pert-groups");
+  const unit = resolved.options.timeUnit;
+  const solid = resolved.options.solidFill === true;
+  const containerFill = mix(palette.surface, palette.bg, 40);
+  const containerStroke = palette.textMuted;
+  const mcOn = resolved.monteCarloResult !== null;
+  const groupHasCritical = (groupId) => resolved.activities.some(
+    (a) => a.activity.groupId === groupId && a.isCriticalPath
+  );
+  const groupBand = (groupId, mcCriticality) => mcOn ? criticalityBand(mcCriticality) : groupHasCritical(groupId) ? "red" : null;
+  for (const grp of layout.groups) {
+    if (grp.width <= 0 || grp.height <= 0) continue;
+    const resolvedGroup = resolved.groups.find((rg) => rg.group.id === grp.id);
+    const label = resolvedGroup?.group.name ?? grp.id;
+    const isCollapsed = collapsedSet.has(grp.id);
+    const memberBand = groupBand(grp.id, resolvedGroup?.criticality ?? null);
+    const memberCritical = groupHasCritical(grp.id);
+    const g = layer.append("g").attr(
+      "class",
+      isCollapsed ? "pert-group pert-group-collapsed" : "pert-group"
+    ).attr("data-group-id", grp.id).attr("data-group-toggle", grp.id).attr("data-collapsed", String(isCollapsed)).attr("data-line-number", String(resolvedGroup?.group.lineNumber ?? 0)).attr("data-critical-path", String(memberCritical)).attr("data-criticality-band", memberBand ?? "").style("cursor", "pointer");
+    if (isCollapsed) {
+      const projectStart = resolved.projectStart;
+      const muStr = formatDuration(resolvedGroup?.rolledMu ?? null, unit, "?");
+      const slackStr = formatSlackValue(
+        resolvedGroup?.slack ?? null,
+        projectStart,
+        unit,
+        "?"
+      );
+      const esStr = formatScheduleValue(
+        resolvedGroup?.es ?? null,
+        projectStart,
+        unit,
+        "?"
+      );
+      const efStr = formatScheduleValue(
+        resolvedGroup?.ef ?? null,
+        projectStart,
+        unit,
+        "?"
+      );
+      const lsStr = formatScheduleValue(
+        resolvedGroup?.ls ?? null,
+        projectStart,
+        unit,
+        "?"
+      );
+      const lfStr = formatScheduleValue(
+        resolvedGroup?.lf ?? null,
+        projectStart,
+        unit,
+        "?"
+      );
+      const cardBaseColor = bandColor(memberBand, palette, palette.primary);
+      const cardFill = shapeFill(palette, cardBaseColor, isDark, { solid });
+      const cardLabelColor = contrastText(
+        cardFill,
+        palette.textOnFillLight,
+        palette.textOnFillDark
+      );
+      const sNR = sc.nodeRadius ?? NODE_RADIUS;
+      const sCBH = sc.collapseBarHeight ?? COLLAPSE_BAR_HEIGHT;
+      drawTextbookCard(g, {
+        width: grp.width,
+        height: grp.height,
+        x: grp.x,
+        y: grp.y,
+        name: label,
+        es: esStr,
+        dur: muStr,
+        ef: efStr,
+        ls: lsStr,
+        slack: slackStr,
+        lf: lfStr,
+        fill: cardFill,
+        stroke: cardBaseColor,
+        labelColor: cardLabelColor,
+        highlightColor: palette.colors.blue,
+        outerColW: sizing.outerColW,
+        midColW: sizing.midColW,
+        sNodeRadius: sc.nodeRadius,
+        sNodeStrokeWidth: sc.nodeStrokeWidth,
+        sNodeTopRowHeight: sc.nodeTopRowHeight,
+        sNodeBottomRowHeight: sc.nodeBottomRowHeight,
+        sNodeFontSize: sc.nodeFontSize,
+        sNodeCellFontSize: sc.nodeCellFontSize,
+        sPinIconW: sc.pinIconW,
+        sPinIconH: sc.pinIconH
+      });
+      const safeGroupId = grp.id.replace(/[^A-Za-z0-9_-]/g, "_");
+      const clipId = `pert-group-clip-${safeGroupId}`;
+      g.append("clipPath").attr("id", clipId).append("rect").attr("x", grp.x).attr("y", grp.y).attr("width", grp.width).attr("height", grp.height).attr("rx", sNR).attr("ry", sNR);
+      g.append("rect").attr("class", "pert-collapse-bar").attr("x", grp.x).attr("y", grp.y + grp.height - sCBH).attr("width", grp.width).attr("height", sCBH).attr("fill", cardBaseColor).attr("clip-path", `url(#${clipId})`);
+      continue;
+    }
+    const sCR = sc.containerRadius ?? CONTAINER_RADIUS;
+    const sCLFS = sc.containerLabelFontSize ?? CONTAINER_LABEL_FONT_SIZE;
+    const sCHH = sc.containerHeaderHeight ?? CONTAINER_HEADER_HEIGHT;
+    const sNSW = sc.nodeStrokeWidth ?? NODE_STROKE_WIDTH;
+    g.append("rect").attr("x", grp.x).attr("y", grp.y).attr("width", grp.width).attr("height", grp.height).attr("rx", sCR).attr("ry", sCR).attr("fill", containerFill).attr("stroke", containerStroke).attr("stroke-opacity", 0.35).attr("stroke-width", sNSW);
+    g.append("text").attr("x", grp.x + grp.width / 2).attr("y", grp.y + sCHH / 2 + sCLFS / 2 - 2).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("fill", palette.text).attr("font-size", sCLFS).attr("font-weight", "bold").text(label);
+  }
+}
+function renderEdges(root, resolved, layout, palette, collapsedSet, sc = {}) {
+  const layer = root.append("g").attr("class", "pert-edges");
+  const criticalSet = new Set(resolved.criticalPath);
+  const mcOn = resolved.monteCarloResult !== null;
+  const edgeByKey = /* @__PURE__ */ new Map();
+  for (const e of resolved.edges) {
+    edgeByKey.set(`${e.source}->${e.target}`, e);
+  }
+  const activityGroup = /* @__PURE__ */ new Map();
+  const critById = /* @__PURE__ */ new Map();
+  for (const a of resolved.activities) {
+    activityGroup.set(a.activity.id, a.activity.groupId);
+    critById.set(a.activity.id, a.criticality);
+  }
+  for (const rg of resolved.groups) {
+    if (!collapsedSet.has(rg.group.id)) continue;
+    let anyCritical = false;
+    let maxC = null;
+    for (const aid of rg.group.activityIds) {
+      if (criticalSet.has(aid)) anyCritical = true;
+      const c = critById.get(aid);
+      if (typeof c === "number") {
+        maxC = maxC === null ? c : Math.max(maxC, c);
+      }
+    }
+    if (anyCritical) criticalSet.add(rg.group.id);
+    critById.set(rg.group.id, maxC);
+  }
+  for (const e of layout.edges) {
+    if (e.points.length < 2) continue;
+    const srcGroup = activityGroup.get(e.source);
+    const tgtGroup = activityGroup.get(e.target);
+    if (srcGroup && tgtGroup && srcGroup === tgtGroup && collapsedSet.has(srcGroup)) {
+      continue;
+    }
+    const isCritical = criticalSet.has(e.source) && criticalSet.has(e.target);
+    let band;
+    if (mcOn) {
+      const sc2 = critById.get(e.source);
+      const tc = critById.get(e.target);
+      const minC = sc2 === null || tc === null || sc2 === void 0 || tc === void 0 ? null : Math.min(sc2, tc);
+      band = criticalityBand(minC);
+      if (band === null && isCritical) band = "red";
+    } else {
+      band = isCritical ? "red" : null;
+    }
+    const path = lineGenerator(e.points);
+    if (!path) continue;
+    const sESW = sc.edgeStrokeWidth ?? EDGE_STROKE_WIDTH;
+    const sELFS = sc.edgeLabelFontSize ?? 10;
+    layer.append("path").attr("class", "pert-edge").attr("d", path).attr("fill", "none").attr("stroke", bandColor(band, palette, palette.textMuted)).attr("stroke-width", sESW).attr("marker-end", `url(#${bandArrow(band)})`).attr("data-source", e.source).attr("data-target", e.target).attr("data-critical", String(isCritical)).attr("data-critical-path", String(isCritical)).attr("data-criticality-band", band ?? "");
+    const parsedEdge = edgeByKey.get(`${e.source}->${e.target}`);
+    const labelText = parsedEdge ? formatEdgeLabel(parsedEdge) : null;
+    if (labelText) {
+      const mid = e.points[Math.floor(e.points.length / 2)];
+      layer.append("text").attr("class", "pert-edge-label").attr("x", mid.x).attr("y", mid.y - 4).attr("text-anchor", "middle").attr("fill", palette.textMuted).attr("font-size", sELFS).attr("paint-order", "stroke").attr("stroke", palette.bg).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("data-edge-source", e.source).attr("data-edge-target", e.target).text(labelText);
+    }
+  }
+}
+function formatEdgeLabel(edge) {
+  if (edge.type === "FS" && edge.lag === null) return null;
+  const parts = [];
+  if (edge.type !== "FS") parts.push(edge.type);
+  if (edge.lag) {
+    const sign = edge.lag.amount >= 0 ? "+" : "-";
+    const amount = Math.abs(edge.lag.amount);
+    parts.push(`${sign}${amount}${edge.lag.unit}`);
+  }
+  return parts.join(" ");
+}
+function renderNodes(root, _defs, resolved, layout, palette, isDark, sizing, onClickItem, collapsedSet = /* @__PURE__ */ new Set(), activeTagOverride, sc = {}) {
+  const layer = root.append("g").attr("class", "pert-nodes");
+  const byId = new Map(resolved.activities.map((r) => [r.activity.id, r]));
+  const tbdSet = new Set(
+    resolved.activities.filter((r) => r.es === null).map((r) => r.activity.id)
+  );
+  const unit = resolved.options.timeUnit;
+  const sprintMode = resolved.options.sprintMode;
+  const sprintNumber = resolved.options.sprintNumber ?? 1;
+  const solid = resolved.options.solidFill === true;
+  const activeTagGroup = resolveActiveTagGroup(
+    resolved.tagGroups,
+    resolved.options.activeTag,
+    activeTagOverride
+  );
+  const projectStart = resolved.projectStart;
+  const fmtSchedule = (v, isTbd) => {
+    if (sprintMode)
+      return formatSprintCell(v, sprintNumber, isTbd ? "?" : null);
+    return formatScheduleValue(v, projectStart, unit, isTbd ? "?" : null);
+  };
+  const fmtSlack = (v, isTbd) => formatSlackValue(v, projectStart, unit, isTbd ? "?" : null);
+  const fmtDur = (v, isTbd) => formatDuration(v, unit, isTbd ? "?" : null);
+  const mcOn = resolved.monteCarloResult !== null;
+  const { topMuIds, bottomMuIds } = computeDurationEmphasis(
+    resolved.activities
+  );
+  const pinnedSet = computeAnchorPinSet(resolved);
+  const anchorKind = resolved.options.anchor?.kind ?? null;
+  for (const node of layout.nodes) {
+    const r = byId.get(node.id);
+    if (!r) continue;
+    if (r.activity.groupId && collapsedSet.has(r.activity.groupId)) continue;
+    const isCritical = r.isCriticalPath;
+    const isTbd = tbdSet.has(node.id);
+    const dashArray = isTbd ? "4,3" : "none";
+    const isTopMu = topMuIds.has(node.id);
+    const isBottomMu = bottomMuIds.has(node.id);
+    let band;
+    if (mcOn) {
+      band = criticalityBand(r.criticality);
+      if (band === null && isCritical) band = "red";
+    } else {
+      band = isCritical ? "red" : null;
+    }
+    const g = layer.append("g").attr("class", "pert-node").attr("transform", `translate(${node.x}, ${node.y})`).attr("data-activity-id", node.id).attr("data-line-number", String(r.activity.lineNumber)).attr(
+      "data-group-id",
+      r.activity.groupId !== void 0 ? r.activity.groupId : ""
+    ).attr("data-critical-path", String(isCritical)).attr("data-criticality-band", band ?? "").attr("data-duration-rank", isTopMu ? "top" : isBottomMu ? "bottom" : "");
+    if (r.activity.tags) {
+      for (const [tagKey, tagValue] of Object.entries(r.activity.tags)) {
+        g.attr(`data-tag-${tagKey}`, String(tagValue).toLowerCase());
+      }
+    }
+    if (pinnedSet.has(node.id) && anchorKind) {
+      g.attr("data-anchor", anchorKind);
+    }
+    if (onClickItem) {
+      g.style("cursor", "pointer").on(
+        "click",
+        () => onClickItem(r.activity.lineNumber)
+      );
+    }
+    const baseColor = bandColor(band, palette, palette.primary);
+    const fill = shapeFill(palette, baseColor, isDark, { solid });
+    const labelColor = contrastText(
+      fill,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    );
+    const tagColor = resolveTagColor(
+      r.activity.tags ?? {},
+      resolved.tagGroups,
+      activeTagGroup
+    );
+    const hasTagColor = tagColor !== void 0 && tagColor !== "#999999";
+    const tagBandFill = hasTagColor ? shapeFill(palette, tagColor, isDark, { solid }) : void 0;
+    const tagLabelColor = hasTagColor ? contrastText(
+      tagBandFill,
+      palette.textOnFillLight,
+      palette.textOnFillDark
+    ) : void 0;
+    if (r.activity.isMilestone) {
+      const slackText = fmtSlack(r.slack, isTbd);
+      const slackHidden = !isTbd && /^0[a-z]?$/.test(slackText);
+      g.attr("data-milestone", "true");
+      if (slackHidden) g.attr("data-milestone-slack-hidden", "true");
+      drawMilestonePill(g, {
+        width: node.width,
+        height: node.height,
+        x: -node.width / 2,
+        y: -node.height / 2,
+        name: `\u25C6 ${r.activity.name}`,
+        date: fmtSchedule(r.es, isTbd),
+        slack: slackText,
+        slackHidden,
+        fill: tagBandFill ?? fill,
+        stroke: baseColor,
+        labelColor: tagLabelColor ?? labelColor,
+        highlightColor: palette.colors.blue,
+        dashArray,
+        pinned: pinnedSet.has(node.id) ? anchorKind : null,
+        sNodeRadius: sc.nodeRadius,
+        sNodeStrokeWidth: sc.nodeStrokeWidth,
+        sNodeTopRowHeight: sc.nodeTopRowHeight,
+        sNodeBottomRowHeight: sc.nodeBottomRowHeight,
+        sNodeCellFontSize: sc.nodeCellFontSize,
+        sPinIconW: sc.pinIconW,
+        sPinIconH: sc.pinIconH
+      });
+      continue;
+    }
+    drawTextbookCard(g, {
+      width: node.width,
+      height: node.height,
+      x: -node.width / 2,
+      y: -node.height / 2,
+      name: r.activity.name,
+      es: fmtSchedule(r.es, isTbd),
+      dur: fmtDur(r.mu, isTbd),
+      ef: fmtSchedule(r.ef, isTbd),
+      ls: fmtSchedule(r.ls, isTbd),
+      slack: fmtSlack(r.slack, isTbd),
+      lf: fmtSchedule(r.lf, isTbd),
+      fill,
+      stroke: baseColor,
+      highlightColor: palette.colors.blue,
+      labelColor,
+      dashArray,
+      emphasis: isTopMu ? "top" : isBottomMu ? "bottom" : null,
+      pinned: pinnedSet.has(node.id) ? anchorKind : null,
+      outerColW: sizing.outerColW,
+      midColW: sizing.midColW,
+      ...tagBandFill !== void 0 && { midBandFill: tagBandFill },
+      ...tagLabelColor !== void 0 && { midBandLabelColor: tagLabelColor },
+      sNodeRadius: sc.nodeRadius,
+      sNodeStrokeWidth: sc.nodeStrokeWidth,
+      sNodeTopRowHeight: sc.nodeTopRowHeight,
+      sNodeBottomRowHeight: sc.nodeBottomRowHeight,
+      sNodeFontSize: sc.nodeFontSize,
+      sNodeCellFontSize: sc.nodeCellFontSize,
+      sPinIconW: sc.pinIconW,
+      sPinIconH: sc.pinIconH
+    });
+  }
+}
+function computeDurationEmphasis(activities) {
+  const ranked = activities.filter(
+    (r) => !r.activity.isMilestone && r.mu !== null && r.mu > 0
+  ).map((r) => ({ id: r.activity.id, mu: r.mu })).sort((a, b) => a.mu - b.mu);
+  if (ranked.length < 5) {
+    return { topMuIds: /* @__PURE__ */ new Set(), bottomMuIds: /* @__PURE__ */ new Set() };
+  }
+  const tierCount = Math.max(1, Math.floor(ranked.length * 0.2));
+  const bottomMuIds = new Set(ranked.slice(0, tierCount).map((b) => b.id));
+  const topMuIds = new Set(ranked.slice(-tierCount).map((b) => b.id));
+  return { topMuIds, bottomMuIds };
+}
+function drawTextbookCard(g, a) {
+  const { width: w, height: h, x, y } = a;
+  const sNR = a.sNodeRadius ?? NODE_RADIUS;
+  const sNSW = a.sNodeStrokeWidth ?? NODE_STROKE_WIDTH;
+  const sTRH = a.sNodeTopRowHeight ?? NODE_TOP_ROW_HEIGHT;
+  const sBRH = a.sNodeBottomRowHeight ?? NODE_BOTTOM_ROW_HEIGHT;
+  const sNFS = a.sNodeFontSize ?? NODE_FONT_SIZE;
+  const sNCFS = a.sNodeCellFontSize ?? NODE_CELL_FONT_SIZE;
+  const sPIW = a.sPinIconW ?? PIN_ICON_W;
+  const sPIH = a.sPinIconH ?? PIN_ICON_H;
+  const outerColW = a.outerColW;
+  const midColW = a.midColW;
+  const topY = y + sTRH;
+  const bottomY = y + h - sBRH;
+  const colX1 = x + outerColW;
+  const colX2 = x + outerColW + midColW;
+  g.append("rect").attr("x", x).attr("y", y).attr("width", w).attr("height", h).attr("rx", sNR).attr("ry", sNR).attr("fill", a.fill).attr("stroke", a.stroke).attr("stroke-width", sNSW).attr("stroke-dasharray", a.dashArray ?? "none");
+  if (a.midBandFill) {
+    g.append("rect").attr("x", x).attr("y", topY).attr("width", w).attr("height", bottomY - topY).attr("fill", a.midBandFill).attr("pointer-events", "none");
+  }
+  const gridColor = a.gridStroke ?? a.stroke;
+  const grid = (x1, y1, x2, y2) => {
+    g.append("line").attr("x1", x1).attr("y1", y1).attr("x2", x2).attr("y2", y2).attr("stroke", gridColor).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+  };
+  grid(x, topY, x + w, topY);
+  grid(x, bottomY, x + w, bottomY);
+  grid(colX1, y, colX1, topY);
+  grid(colX2, y, colX2, topY);
+  grid(colX1, bottomY, colX1, y + h);
+  grid(colX2, bottomY, colX2, y + h);
+  const drawCellHighlight = (field, cx, cy, cw, ch) => {
+    g.append("rect").attr("class", "pert-cell-highlight").attr("data-field", field).attr("x", cx).attr("y", cy).attr("width", cw).attr("height", ch).attr("fill", a.highlightColor).attr("fill-opacity", 0).attr("pointer-events", "none");
+  };
+  drawCellHighlight("es", x, y, outerColW, sTRH);
+  drawCellHighlight("dur", x + outerColW, y, midColW, sTRH);
+  drawCellHighlight("ef", x + outerColW + midColW, y, outerColW, sTRH);
+  drawCellHighlight("ls", x, bottomY, outerColW, sBRH);
+  drawCellHighlight("slack", x + outerColW, bottomY, midColW, sBRH);
+  drawCellHighlight("lf", x + outerColW + midColW, bottomY, outerColW, sBRH);
+  const drawCell = (cx, cy, text, weight = "normal", size = sNCFS, opacity = 1, colorOverride) => {
+    const t = g.append("text").attr("x", cx).attr("y", cy + size / 2 - 2).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("fill", colorOverride ?? a.labelColor).attr("font-size", size).attr("font-weight", weight).text(text);
+    if (opacity !== 1) t.attr("opacity", String(opacity));
+  };
+  const topMid = y + sTRH / 2;
+  const durWeight = a.emphasis === "top" ? "bold" : "normal";
+  const durOpacity = a.emphasis === "bottom" ? DURATION_FADE_OPACITY : 1;
+  const esWeight = a.pinned === "forward" ? "bold" : "normal";
+  const efWeight = a.pinned === "backward" ? "bold" : "normal";
+  drawCell(x + outerColW / 2, topMid, a.es, esWeight);
+  drawCell(
+    x + outerColW + midColW / 2,
+    topMid,
+    a.dur,
+    durWeight,
+    sNCFS,
+    durOpacity
+  );
+  drawCell(x + outerColW + midColW + outerColW / 2, topMid, a.ef, efWeight);
+  const midRowTop = y + sTRH;
+  const midRowH = h - sTRH - sBRH;
+  const midCenterY = midRowTop + midRowH / 2;
+  const NAME_PAD_X = 6;
+  const NAME_PIN_GAP = 4;
+  const pinReserve = a.pinned ? sPIW + NAME_PIN_GAP : 0;
+  const availTextW = Math.max(0, w - 2 * NAME_PAD_X - pinReserve);
+  const displayName = truncateText(a.name, sNFS, availTextW);
+  const nameColor = a.midBandLabelColor ?? a.labelColor;
+  if (a.pinned) {
+    drawAnchorPin(g, x + NAME_PAD_X, midCenterY, nameColor, sPIW, sPIH);
+    const textAreaLeft = x + NAME_PAD_X + sPIW + NAME_PIN_GAP;
+    const textAreaRight = x + w - NAME_PAD_X;
+    const textCx = (textAreaLeft + textAreaRight) / 2;
+    drawCell(
+      textCx,
+      midCenterY,
+      displayName,
+      "bold",
+      sNFS,
+      1,
+      a.midBandLabelColor
+    );
+  } else {
+    drawCell(
+      x + w / 2,
+      midCenterY,
+      displayName,
+      "bold",
+      sNFS,
+      1,
+      a.midBandLabelColor
+    );
+  }
+  const botMid = y + h - sBRH / 2;
+  const lsWeight = esWeight;
+  const lfWeight = efWeight;
+  drawCell(x + outerColW / 2, botMid, a.ls, lsWeight);
+  drawCell(x + outerColW + midColW / 2, botMid, a.slack);
+  drawCell(x + outerColW + midColW + outerColW / 2, botMid, a.lf, lfWeight);
+}
+function drawMilestonePill(g, a) {
+  const { width: w, height: h, x, y } = a;
+  const sNR = a.sNodeRadius ?? NODE_RADIUS;
+  const sNSW = a.sNodeStrokeWidth ?? NODE_STROKE_WIDTH;
+  const topRowH = a.sNodeTopRowHeight ?? NODE_TOP_ROW_HEIGHT;
+  const botRowH = a.sNodeBottomRowHeight ?? NODE_BOTTOM_ROW_HEIGHT;
+  const sNCFS = a.sNodeCellFontSize ?? NODE_CELL_FONT_SIZE;
+  const sPIW = a.sPinIconW ?? PIN_ICON_W;
+  const sPIH = a.sPinIconH ?? PIN_ICON_H;
+  const topY = y + topRowH;
+  const bottomY = y + h - botRowH;
+  g.append("rect").attr("x", x).attr("y", y).attr("width", w).attr("height", h).attr("rx", sNR).attr("ry", sNR).attr("fill", a.fill).attr("stroke", a.stroke).attr("stroke-width", sNSW).attr("stroke-dasharray", a.dashArray ?? "none");
+  const grid = (x1, y1, x2, y2) => {
+    g.append("line").attr("x1", x1).attr("y1", y1).attr("x2", x2).attr("y2", y2).attr("stroke", a.stroke).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+  };
+  grid(x, topY, x + w, topY);
+  if (!a.slackHidden) grid(x, bottomY, x + w, bottomY);
+  const addCellHighlight = (field, cx, cy, cw, ch) => {
+    g.append("rect").attr("class", "pert-cell-highlight").attr("data-field", field).attr("x", cx).attr("y", cy).attr("width", cw).attr("height", ch).attr("fill", a.highlightColor).attr("fill-opacity", 0).attr("pointer-events", "none");
+  };
+  addCellHighlight("es", x, y, w, topRowH);
+  addCellHighlight("ef", x, y, w, topRowH);
+  if (!a.slackHidden) {
+    addCellHighlight("slack", x, bottomY, w, botRowH);
+  }
+  const drawCenteredText = (cx, cy, text, weight, size) => {
+    g.append("text").attr("x", cx).attr("y", cy + size / 2 - 2).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("fill", a.labelColor).attr("font-size", size).attr("font-weight", weight).text(text);
+  };
+  drawCenteredText(x + w / 2, y + topRowH / 2, a.date, "normal", sNCFS);
+  const midRowTop = y + topRowH;
+  const midRowH = h - topRowH - botRowH;
+  const midCenterY = midRowTop + midRowH / 2;
+  const nameSize = 12;
+  const NAME_PAD_X = 6;
+  const NAME_PIN_GAP = 4;
+  const NAME_LINE_HEIGHT = 14;
+  let textAreaLeft = x + NAME_PAD_X;
+  const textAreaRight = x + w - NAME_PAD_X;
+  if (a.pinned) {
+    drawAnchorPin(g, x + NAME_PAD_X, midCenterY, a.labelColor, sPIW, sPIH);
+    textAreaLeft = x + NAME_PAD_X + sPIW + NAME_PIN_GAP;
+  }
+  const textCx = (textAreaLeft + textAreaRight) / 2;
+  const availW = textAreaRight - textAreaLeft;
+  const lines = wrapTextToWidth(a.name, nameSize, availW, { hardBreak: true });
+  const maxLines = Math.max(1, Math.floor(midRowH / NAME_LINE_HEIGHT));
+  const visibleLines = lines.slice(0, maxLines);
+  if (lines.length > maxLines && visibleLines.length > 0) {
+    const last = visibleLines[visibleLines.length - 1];
+    const withEllipsis = `${last}\u2026`;
+    visibleLines[visibleLines.length - 1] = measureText(withEllipsis, nameSize) <= availW ? withEllipsis : truncateText(last, nameSize, availW);
+  }
+  const startCy = midCenterY - (visibleLines.length - 1) * NAME_LINE_HEIGHT / 2;
+  visibleLines.forEach((line2, i) => {
+    drawCenteredText(
+      textCx,
+      startCy + i * NAME_LINE_HEIGHT,
+      line2,
+      "bold",
+      nameSize
+    );
+  });
+  if (!a.slackHidden) {
+    drawCenteredText(x + w / 2, y + h - botRowH / 2, a.slack, "normal", sNCFS);
+  }
+}
+function drawAnchorPin(g, left, centerY, color, pinW = PIN_ICON_W, pinH = PIN_ICON_H) {
+  const scale = pinW / 24;
+  const top = centerY - pinH / 2;
+  const pin = g.append("g").attr("class", "pert-pin").attr("data-pert-pin", "").attr("transform", `translate(${left}, ${top}) scale(${scale})`);
+  pin.append("path").attr("d", "M12 22V8 M5 12H2a10 10 0 0 0 20 0h-3").attr("fill", "none").attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+  pin.append("circle").attr("cx", 12).attr("cy", 5).attr("r", 3).attr("fill", "none").attr("stroke", color).attr("stroke-width", 2);
+}
+function computeAnchorPinSet(resolved) {
+  const anchor = resolved.options.anchor;
+  if (anchor === null) return /* @__PURE__ */ new Set();
+  const inDeg = /* @__PURE__ */ new Map();
+  const outDeg = /* @__PURE__ */ new Map();
+  for (const a of resolved.activities) {
+    inDeg.set(a.activity.id, 0);
+    outDeg.set(a.activity.id, 0);
+  }
+  for (const e of resolved.edges) {
+    outDeg.set(e.source, (outDeg.get(e.source) ?? 0) + 1);
+    inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
+  }
+  const pinned = /* @__PURE__ */ new Set();
+  for (const a of resolved.activities) {
+    if (anchor.kind === "forward" && (inDeg.get(a.activity.id) ?? 0) === 0) {
+      pinned.add(a.activity.id);
+    } else if (anchor.kind === "backward" && (outDeg.get(a.activity.id) ?? 0) === 0) {
+      pinned.add(a.activity.id);
+    }
+  }
+  return pinned;
+}
+function anchorAnnotationText(resolved) {
+  const anchor = resolved.options.anchor;
+  if (anchor === null) return null;
+  const today = resolved.options.today;
+  if (anchor.kind === "forward") {
+    return `Forward from start-date ${anchor.date}`;
+  }
+  const asOf = today ? ` (as of ${today})` : "";
+  if (resolved.projectStart) {
+    return `Backward-anchored from end-date ${anchor.date}${asOf}`;
+  }
+  return `Backward-anchored from end-date ${anchor.date}${asOf} \u2014 upstream activities still need estimates`;
+}
+function bulletizeCaption(rows) {
+  return rows.map((row) => {
+    const out = { text: row.text, level: row.level };
+    if (row.italic) out.italic = true;
+    if (row.isPast) out.isPast = true;
+    return out;
+  });
+}
+var SUB_BULLET_INDENT = 20;
+var CAPTION_HEADER_BAND_HEIGHT = CAPTION_LINE_HEIGHT + 8;
+function captionNaturalWidth(bullets) {
+  const charW = CAPTION_FONT_SIZE * 0.55;
+  let max = "Summary".length * charW;
+  for (const b of bullets) {
+    const indent = b.level === 1 ? SUB_BULLET_INDENT : 0;
+    const w = indent + `\u2022 ${b.text}`.length * charW;
+    if (w > max) max = w;
+  }
+  return Math.ceil(max + 2 * CAPTION_BOX_PADDING_X);
+}
+var TORNADO_TOP_N = 10;
+var TORNADO_ROW_HEIGHT = 26;
+var TORNADO_NAME_COL_W = 160;
+var TORNADO_BAR_FONT_SIZE = 13;
+var TORNADO_BAR_HEIGHT = 16;
+var SUMMARY_MIN_W = 260;
+var SUMMARY_MAX_W = 420;
+var ANALYSIS_GAP = 16;
+var COL1_VSTACK_GAP = 8;
+var TORNADO_MIN_W = 340;
+var SCURVE_MIN_W = 320;
+var SCURVE_BOX_HEIGHT = 220;
+var SCURVE_PLOT_PADDING_X = 64;
+var SCURVE_PLOT_PADDING_RIGHT = 16;
+var SCURVE_PLOT_PADDING_BOTTOM = 44;
+var SCURVE_TICK_FONT_SIZE = 13;
+var SCURVE_PERCENTILE_RADIUS = 4;
+function renderCaptionBlock(svg, bullets, args) {
+  const { x, y, width, height, palette, isDark } = args;
+  const { fill, stroke: chromeStroke } = analysisBlockChrome(palette, isDark);
+  const labelColor = contrastText(
+    fill,
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const block = svg.append("g").attr("class", "pert-caption-block").attr("data-pert-caption", "");
+  block.append("rect").attr("class", "pert-caption-rect").attr("x", x).attr("y", y).attr("width", width).attr("height", height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS).attr("fill", fill).attr("stroke", chromeStroke).attr("stroke-width", NODE_STROKE_WIDTH);
+  block.append("text").attr("class", "pert-caption-header").attr("x", x + width / 2).attr("y", y + CAPTION_BOX_PADDING_Y + CAPTION_FONT_SIZE).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", CAPTION_FONT_SIZE).attr("font-weight", "700").text("Summary");
+  const textX = x + CAPTION_BOX_PADDING_X;
+  const firstBaselineY = y + CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT + CAPTION_FONT_SIZE;
+  const text = block.append("text").attr("class", "pert-caption").attr("x", textX).attr("y", firstBaselineY).attr("text-anchor", "start").attr("fill", labelColor).attr("font-size", CAPTION_FONT_SIZE).attr("font-weight", CAPTION_FONT_WEIGHT);
+  bullets.forEach((bullet, i) => {
+    const indent = bullet.level === 1 ? SUB_BULLET_INDENT : 0;
+    const tspan = text.append("tspan").attr("x", textX + indent).text(`\u2022 ${bullet.text}`);
+    if (bullet.italic) tspan.attr("font-style", "italic");
+    if (i > 0) tspan.attr("dy", CAPTION_LINE_HEIGHT);
+  });
+}
+function renderTagLegendRow(svg, resolved, palette, isDark, args) {
+  if (resolved.tagGroups.length === 0) return;
+  const { x, y, width, activeGroup, exportMode } = args;
+  const groups = resolved.tagGroups.map((g) => ({
+    name: g.name,
+    entries: g.entries.map((e) => ({ value: e.value, color: e.color }))
+  }));
+  const block = svg.append("g").attr("class", "pert-tag-legend").attr("transform", `translate(${x}, ${y})`);
+  renderIntegratedLegend(block, {
+    groups,
+    mode: exportMode ? "export" : "preview",
+    palette,
+    isDark,
+    width,
+    activeGroup
+  });
+}
+function renderFieldLegendBlock(svg, args) {
+  const { x, y, width, height, palette, isDark } = args;
+  const baseColor = palette.textMuted;
+  const labelColor = contrastText(
+    shapeFill(palette, baseColor, isDark),
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const headerY = y + CAPTION_BOX_PADDING_Y + CAPTION_FONT_SIZE;
+  const colW = width / 3;
+  const gridTop = y + CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT;
+  const gridBottom = y + height;
+  const rowH = (gridBottom - gridTop) / 2;
+  const block = svg.append("g").attr("class", "pert-field-legend").attr("data-pert-field-legend", "");
+  block.append("rect").attr("class", "pert-field-legend-rect").attr("x", x).attr("y", y).attr("width", width).attr("height", height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS).attr("fill", "none").attr("stroke", baseColor).attr("stroke-opacity", 0.4).attr("stroke-width", 1);
+  block.append("text").attr("class", "pert-field-legend-header").attr("x", x + width / 2).attr("y", headerY).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", CAPTION_FONT_SIZE).attr("font-weight", "700").text("Field labels");
+  const grid = (x1, y1, x2, y2) => {
+    block.append("line").attr("x1", x1).attr("y1", y1).attr("x2", x2).attr("y2", y2).attr("stroke", baseColor).attr("stroke-opacity", 0.3).attr("stroke-width", 1);
+  };
+  grid(x, gridTop + rowH, x + width, gridTop + rowH);
+  grid(x + colW, gridTop, x + colW, gridBottom);
+  grid(x + colW * 2, gridTop, x + colW * 2, gridBottom);
+  const FIELD_BY_INDEX = ["es", "dur", "ef", "ls", "slack", "lf"];
+  FIELD_LEGEND_CELLS.forEach((cell, i) => {
+    const col = i % 3;
+    const row = Math.floor(i / 3);
+    const cx = x + col * colW + colW / 2;
+    const cellTop = gridTop + row * rowH;
+    const field = FIELD_BY_INDEX[i];
+    const cellG = block.append("g").attr("class", "pert-field-legend-cell").attr("data-field", field);
+    cellG.append("rect").attr("class", "pert-cell-highlight").attr("data-field", field).attr("x", x + col * colW).attr("y", cellTop).attr("width", colW).attr("height", rowH).attr("fill", palette.colors.blue).attr("fill-opacity", 0).attr("pointer-events", "all");
+    const descLines = wrapTextToWidth(
+      cell.desc,
+      FIELD_LEGEND_DESC_FONT_SIZE,
+      fieldLegendDescWidth(colW)
+    );
+    const descBlockHeight = FIELD_LEGEND_DESC_FONT_SIZE + Math.max(descLines.length - 1, 0) * FIELD_LEGEND_DESC_LINE_HEIGHT;
+    const stackHeight = FIELD_LEGEND_LABEL_FONT_SIZE + FIELD_LEGEND_LABEL_DESC_GAP + descBlockHeight;
+    const stackTop = cellTop + Math.max((rowH - stackHeight) / 2, 0);
+    const labelY = stackTop + FIELD_LEGEND_LABEL_FONT_SIZE;
+    const firstDescY = labelY + FIELD_LEGEND_LABEL_DESC_GAP + FIELD_LEGEND_DESC_FONT_SIZE;
+    cellG.append("text").attr("class", "pert-field-legend-label").attr("x", cx).attr("y", labelY).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", FIELD_LEGEND_LABEL_FONT_SIZE).attr("font-weight", 600).attr("fill", labelColor).text(cell.label);
+    const descText = cellG.append("text").attr("class", "pert-field-legend-desc").attr("x", cx).attr("y", firstDescY).attr("text-anchor", "middle").attr("font-family", FONT_FAMILY).attr("font-size", FIELD_LEGEND_DESC_FONT_SIZE).attr("fill", labelColor).attr("opacity", 0.85);
+    descLines.forEach((line2, idx) => {
+      const tspan = descText.append("tspan").attr("x", cx).text(line2);
+      if (idx > 0) tspan.attr("dy", FIELD_LEGEND_DESC_LINE_HEIGHT);
+    });
+  });
+}
+function buildTornadoRows(resolved, maxN = TORNADO_TOP_N) {
+  if (resolved.monteCarloResult === null) return [];
+  const swings = resolved.monteCarloResult.tornadoSwings ?? [];
+  if (swings.length === 0) return [];
+  const sprintDays = resolveSprintDaysFromOptions(resolved.options);
+  const unit = resolved.options.timeUnit;
+  const rows = swings.map((s) => ({
+    id: s.id,
+    name: s.name,
+    lowSwing: fromDisplayUnit(s.lowSwing, unit, sprintDays),
+    highSwing: fromDisplayUnit(s.highSwing, unit, sprintDays),
+    band: criticalityBand(s.criticality)
+  }));
+  return rows.slice(0, Math.max(1, maxN));
+}
+function fromDisplayUnit(days, unit, sprintDays) {
+  const unitDays = unit === "s" && sprintDays !== void 0 ? sprintDays : DAYS_PER_UNIT[unit];
+  return days / unitDays;
+}
+function resolveSprintDaysFromOptions(opts) {
+  if (!opts.sprintMode || !opts.sprintLength) return void 0;
+  return opts.sprintLength.amount * DAYS_PER_UNIT[opts.sprintLength.unit];
+}
+var DAYS_PER_UNIT = {
+  min: 1 / (60 * 24),
+  h: 1 / 24,
+  d: 1,
+  bd: 1,
+  w: 7,
+  m: 30,
+  q: 90,
+  y: 365,
+  s: 14
+};
+function tornadoMaxRowsFor(boxHeight) {
+  const rowSpace = boxHeight - 2 * CAPTION_BOX_PADDING_Y - CAPTION_HEADER_BAND_HEIGHT;
+  return Math.max(1, Math.floor(rowSpace / TORNADO_ROW_HEIGHT));
+}
+function tornadoBoxHeightFor(rows) {
+  return rows.length * TORNADO_ROW_HEIGHT + 2 * CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT;
+}
+function renderTornadoBlock(svg, rows, args) {
+  const { x, y, width, height, palette, isDark } = args;
+  const { fill, stroke: chromeStroke } = analysisBlockChrome(palette, isDark);
+  const labelColor = contrastText(
+    fill,
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const block = svg.append("g").attr("class", "pert-tornado-block").attr("data-pert-tornado", "");
+  block.append("rect").attr("class", "pert-tornado-rect").attr("x", x).attr("y", y).attr("width", width).attr("height", height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS).attr("fill", fill).attr("stroke", chromeStroke).attr("stroke-width", NODE_STROKE_WIDTH);
+  block.append("text").attr("class", "pert-tornado-header").attr("x", x + width / 2).attr("y", y + CAPTION_BOX_PADDING_Y + CAPTION_FONT_SIZE).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", CAPTION_FONT_SIZE).attr("font-weight", "700").text("Activity Risk");
+  const fmt = (v) => {
+    const r = Math.round(v * 100) / 100;
+    return r.toFixed(2).replace(/\.?0+$/, "");
+  };
+  const maxLow = rows.reduce((acc, r) => Math.max(acc, r.lowSwing), 0);
+  const maxHigh = rows.reduce((acc, r) => Math.max(acc, r.highSwing), 0);
+  const totalRange = maxLow + maxHigh || 1;
+  const nameX = x + CAPTION_BOX_PADDING_X;
+  const plotLeft = nameX + TORNADO_NAME_COL_W;
+  const plotRight = x + width - CAPTION_BOX_PADDING_X;
+  const VALUE_GAP = 6;
+  const CHAR_W = TORNADO_BAR_FONT_SIZE * 0.6;
+  const longestLeftLabelChars = rows.reduce(
+    (acc, r) => r.lowSwing > 0 ? Math.max(acc, `\u2212${fmt(r.lowSwing)}`.length) : acc,
+    0
+  );
+  const longestRightLabelChars = rows.reduce(
+    (acc, r) => r.highSwing > 0 ? Math.max(acc, `+${fmt(r.highSwing)}`.length) : acc,
+    0
+  );
+  const leftGutter = longestLeftLabelChars > 0 ? longestLeftLabelChars * CHAR_W + VALUE_GAP + 2 : 0;
+  const rightGutter = longestRightLabelChars > 0 ? longestRightLabelChars * CHAR_W + VALUE_GAP + 2 : 0;
+  const innerLeft = plotLeft + leftGutter;
+  const innerRight = plotRight - rightGutter;
+  const plotWidth = Math.max(innerRight - innerLeft, 0);
+  const pixelsPerUnit = plotWidth / totalRange;
+  const leftWidth = maxLow * pixelsPerUnit;
+  const centerX = innerLeft + leftWidth;
+  const firstRowY = y + CAPTION_BOX_PADDING_Y + CAPTION_HEADER_BAND_HEIGHT;
+  rows.forEach((row, i) => {
+    const rowY = firstRowY + i * TORNADO_ROW_HEIGHT;
+    const labelY = rowY + TORNADO_ROW_HEIGHT / 2 + TORNADO_BAR_FONT_SIZE / 2 - 2;
+    const barColor = bandColor(row.band, palette, palette.primary);
+    const barFill = shapeFill(palette, barColor, isDark);
+    const lowW = row.lowSwing * pixelsPerUnit;
+    const highW = row.highSwing * pixelsPerUnit;
+    const rowG = block.append("g").attr("class", "pert-tornado-row").attr("data-activity-id", row.id).attr("data-tornado-swing", String(row.lowSwing + row.highSwing));
+    rowG.append("rect").attr("class", "pert-tornado-row-hit").attr("x", nameX).attr("y", rowY).attr("width", plotRight - nameX).attr("height", TORNADO_ROW_HEIGHT).attr("fill", "transparent").attr("pointer-events", "all");
+    const truncated = row.name.length > 22 ? row.name.slice(0, 21) + "\u2026" : row.name;
+    rowG.append("text").attr("class", "pert-tornado-name").attr("x", nameX).attr("y", labelY).attr("text-anchor", "start").attr("fill", labelColor).attr("font-size", TORNADO_BAR_FONT_SIZE).text(truncated);
+    if (lowW > 0) {
+      rowG.append("rect").attr("class", "pert-tornado-bar pert-tornado-bar-low").attr("x", centerX - lowW).attr("y", rowY + (TORNADO_ROW_HEIGHT - TORNADO_BAR_HEIGHT) / 2).attr("width", lowW).attr("height", TORNADO_BAR_HEIGHT).attr("rx", 2).attr("ry", 2).attr("fill", barFill).attr("stroke", barColor).attr("stroke-width", 1);
+      rowG.append("text").attr("class", "pert-tornado-value pert-tornado-value-low").attr("x", centerX - lowW - VALUE_GAP).attr("y", labelY).attr("text-anchor", "end").attr("fill", labelColor).attr("font-size", TORNADO_BAR_FONT_SIZE).text(`\u2212${fmt(row.lowSwing)}`);
+    }
+    if (highW > 0) {
+      rowG.append("rect").attr("class", "pert-tornado-bar pert-tornado-bar-high").attr("x", centerX).attr("y", rowY + (TORNADO_ROW_HEIGHT - TORNADO_BAR_HEIGHT) / 2).attr("width", highW).attr("height", TORNADO_BAR_HEIGHT).attr("rx", 2).attr("ry", 2).attr("fill", barFill).attr("stroke", barColor).attr("stroke-width", 1);
+      rowG.append("text").attr("class", "pert-tornado-value pert-tornado-value-high").attr("x", centerX + highW + VALUE_GAP).attr("y", labelY).attr("text-anchor", "start").attr("fill", labelColor).attr("font-size", TORNADO_BAR_FONT_SIZE).text(`+${fmt(row.highSwing)}`);
+    }
+  });
+  if (rows.length > 0) {
+    const axisTop = firstRowY;
+    const axisBottom = firstRowY + rows.length * TORNADO_ROW_HEIGHT;
+    block.append("line").attr("class", "pert-tornado-axis").attr("x1", centerX).attr("x2", centerX).attr("y1", axisTop).attr("y2", axisBottom).attr("stroke", labelColor).attr("stroke-width", 1).attr("opacity", 0.5);
+  }
+}
+function buildScurveData(resolved) {
+  const mc = resolved.monteCarloResult;
+  if (mc === null) return null;
+  const p5 = Math.max(0, 2 * mc.p50 - mc.p95);
+  const durationSamples = [p5, mc.p50, mc.p80, mc.p95];
+  if (durationSamples.every((v) => v === durationSamples[0])) return null;
+  const anchor = resolved.options.anchor;
+  const mode = anchor?.kind === "backward" ? "backward" : "forward";
+  const yAxisLabel = "Probability of completion";
+  const today = resolved.options.today;
+  let deadlineDays = null;
+  let deadlineDate = null;
+  if (anchor !== null && anchor.kind === "backward" && resolved.projectStart !== null) {
+    const startMs = Date.parse(resolved.projectStart);
+    const endMs = Date.parse(anchor.date);
+    if (!isNaN(startMs) && !isNaN(endMs)) {
+      deadlineDays = (endMs - startMs) / (1e3 * 60 * 60 * 24);
+      deadlineDate = anchor.date;
+    }
+  }
+  const projectSmooth = (durationDays) => mode === "backward" && deadlineDays !== null ? deadlineDays - durationDays : durationDays;
+  const projectRounded = (durationDays) => mode === "backward" && deadlineDays !== null ? deadlineDays - Math.ceil(durationDays) : durationDays;
+  const durationProbPairs = [
+    // In-bounds: MC always produces samples; consumers gate on `mc.minDurationDays !== null`.
+    { d: durationSamples[0], p: 0.05 },
+    { d: mc.p50, p: 0.5 },
+    { d: mc.p80, p: 0.8 },
+    { d: mc.p95, p: 0.95 }
+  ];
+  const curvePoints = durationProbPairs.map(({ d, p }) => ({ x: projectSmooth(d), y: p })).sort((a, b) => a.x - b.x);
+  const samples = durationSamples.map(projectSmooth).sort((a, b) => a - b);
+  const p16Proj = projectSmooth(mc.p16);
+  const p84Proj = projectSmooth(mc.p84);
+  const bandLeft = Math.min(p16Proj, p84Proj);
+  const bandRight = Math.max(p16Proj, p84Proj);
+  const referenceLines = [
+    { pct: 50, days: mc.p50 },
+    { pct: 80, days: mc.p80 },
+    { pct: 95, days: mc.p95 }
+  ].map(({ pct, days }) => {
+    const yFrac = pct / 100;
+    if (mode === "backward" && anchor?.kind === "backward") {
+      const offsetDays = Math.ceil(days);
+      const date = addCalendarDays(anchor.date, -offsetDays);
+      const isPast = today.length > 0 && date < today;
+      const label = `P${pct} latest-safe start${isPast ? " (past)" : ""}`;
+      return {
+        x: projectRounded(days),
+        y: yFrac,
+        durationDays: days,
+        label,
+        isPast
+      };
+    }
+    return {
+      x: days,
+      y: yFrac,
+      durationDays: days,
+      label: `P${pct} finish`,
+      isPast: false
+    };
+  });
+  const xMinDays = mode === "backward" && deadlineDays !== null ? deadlineDays - mc.maxDurationDays : (
+    // In-bounds: MC always produces samples.
+    Math.min(durationSamples[0], mc.minDurationDays)
+  );
+  const xMaxDays = mode === "backward" && deadlineDays !== null ? deadlineDays : Math.max(mc.p95, mc.maxDurationDays);
+  return {
+    mode,
+    yAxisLabel,
+    curvePoints,
+    samples,
+    p16Days: bandLeft,
+    p84Days: bandRight,
+    // Percentile dots/date-labels — `projectRounded` matches the
+    // analyzer's `roundConservative` (Math.ceil of the duration), so
+    // each dot's date label is byte-identical to the caption's
+    // "P{X} latest-safe start: <date>" row.
+    p50Days: projectRounded(mc.p50),
+    p80Days: projectRounded(mc.p80),
+    p95Days: projectRounded(mc.p95),
+    xMinDays,
+    xMaxDays,
+    referenceLines,
+    framingNote: anchorAnnotationText(resolved),
+    anchorDate: resolved.projectStart,
+    deadlineDays,
+    deadlineDate
+  };
+}
+function renderScurveBlock(svg, data, args) {
+  const { x, y, width, height, palette, isDark, unit, title } = args;
+  const { fill, stroke: chromeStroke } = analysisBlockChrome(palette, isDark);
+  const labelColor = contrastText(
+    fill,
+    palette.textOnFillLight,
+    palette.textOnFillDark
+  );
+  const block = svg.append("g").attr("class", "pert-scurve-block").attr("data-pert-scurve", "");
+  block.append("rect").attr("class", "pert-scurve-rect").attr("x", x).attr("y", y).attr("width", width).attr("height", height).attr("rx", NODE_RADIUS).attr("ry", NODE_RADIUS).attr("fill", fill).attr("stroke", chromeStroke).attr("stroke-width", NODE_STROKE_WIDTH);
+  const hasTitle = typeof title === "string" && title.length > 0;
+  if (hasTitle) {
+    const titleText = title.replace(/\.$/, "");
+    block.append("text").attr("class", "pert-scurve-header").attr("x", x + width / 2).attr("y", y + CAPTION_BOX_PADDING_Y + CAPTION_FONT_SIZE).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", CAPTION_FONT_SIZE).attr("font-weight", "700").text(titleText);
+  }
+  const SCURVE_DEADLINE_LABEL_HEIGHT = 16;
+  const hasDeadline = data.deadlineDays !== null;
+  const plotLeft = x + SCURVE_PLOT_PADDING_X;
+  const plotRight = x + width - SCURVE_PLOT_PADDING_RIGHT;
+  const plotTop = y + CAPTION_BOX_PADDING_Y + (hasTitle ? CAPTION_HEADER_BAND_HEIGHT : 0) + (hasDeadline ? SCURVE_DEADLINE_LABEL_HEIGHT : 0);
+  const isAnchored = data.anchorDate !== null;
+  const plotBottom = y + height - SCURVE_PLOT_PADDING_BOTTOM;
+  const plotW = plotRight - plotLeft;
+  const plotH = plotBottom - plotTop;
+  const dotPositions = [data.p50Days, data.p80Days, data.p95Days];
+  const dotMin = Math.min(...dotPositions);
+  const dotMax = Math.max(...dotPositions);
+  const dotSpan = Math.max(1, dotMax - dotMin);
+  const xMin = Math.min(data.p16Days, dotMin - 0.2 * dotSpan);
+  const xMax = data.mode === "backward" && data.deadlineDays !== null ? data.deadlineDays : Math.max(data.p84Days, dotMax + 0.2 * dotSpan);
+  const xRange = xMax - xMin || 1;
+  const xScale = (v) => plotLeft + (v - xMin) / xRange * plotW;
+  const yScale = (frac) => plotBottom - frac * plotH;
+  const yTicks = [0, 0.25, 0.5, 0.75, 1];
+  for (const t of yTicks) {
+    const yy = yScale(t);
+    block.append("line").attr("class", "pert-scurve-grid").attr("x1", plotLeft).attr("x2", plotRight).attr("y1", yy).attr("y2", yy).attr("stroke", palette.textMuted).attr("stroke-width", 1).attr("opacity", t === 0 || t === 1 ? 0.4 : 0.15);
+    block.append("text").attr("class", "pert-scurve-ytick").attr("x", plotLeft - 6).attr("y", yy + SCURVE_TICK_FONT_SIZE / 3).attr("text-anchor", "end").attr("fill", labelColor).attr("font-size", SCURVE_TICK_FONT_SIZE).text(`${Math.round(t * 100)}%`);
+  }
+  const yAxisLabelCx = x + 14;
+  const yAxisLabelCy = plotTop + plotH / 2;
+  block.append("text").attr("class", "pert-scurve-y-axis-title").attr(
+    "transform",
+    `translate(${yAxisLabelCx}, ${yAxisLabelCy}) rotate(-90)`
+  ).attr("text-anchor", "middle").attr("fill", labelColor).attr("font-size", SCURVE_TICK_FONT_SIZE - 1).attr("font-weight", "600").attr("opacity", 0.85).text(data.yAxisLabel);
+  if (data.p84Days > data.p16Days) {
+    const bandLeftRaw = xScale(data.p16Days);
+    const bandRightRaw = xScale(data.p84Days);
+    const bandLeft = Math.max(plotLeft, bandLeftRaw);
+    const bandRight = Math.min(plotRight, bandRightRaw);
+    if (bandRight > bandLeft) {
+      block.append("rect").attr("class", "pert-scurve-likely-band").attr("x", bandLeft).attr("y", plotTop).attr("width", bandRight - bandLeft).attr("height", plotH).attr("fill", palette.colors.blue).attr("opacity", 0.12);
+    }
+  }
+  if (data.deadlineDays !== null && data.deadlineDate !== null) {
+    const dx = xScale(data.deadlineDays);
+    if (dx >= plotLeft - 1 && dx <= plotRight + 1) {
+      const deadlineColor = palette.colors.purple;
+      const edgePad = 4;
+      let anchor = "middle";
+      if (dx <= plotLeft + edgePad) anchor = "start";
+      else if (dx >= plotRight - edgePad) anchor = "end";
+      block.append("text").attr("class", "pert-scurve-deadline-label").attr("x", dx).attr("y", plotTop - 4).attr("text-anchor", anchor).attr("fill", deadlineColor).attr("font-size", SCURVE_TICK_FONT_SIZE).attr("font-weight", "700").text(`Deadline \xB7 ${formatScurveDate(data.deadlineDate)}`);
+      block.append("line").attr("class", "pert-scurve-deadline-line").attr("x1", dx).attr("x2", dx).attr("y1", plotTop).attr("y2", plotBottom).attr("stroke", deadlineColor).attr("stroke-width", 1.5).attr("opacity", 0.9);
+    }
+  }
+  const points = data.curvePoints.map((pt) => ({
+    x: xScale(pt.x),
+    y: yScale(pt.y)
+  }));
+  const curve = d3Shape.line().x((d) => d.x).y((d) => d.y).curve(d3Shape.curveMonotoneX)(points);
+  if (curve) {
+    const clipId = `pert-scurve-clip-${Math.random().toString(36).slice(2, 10)}`;
+    block.append("clipPath").attr("id", clipId).append("rect").attr("x", plotLeft).attr("y", plotTop).attr("width", plotW).attr("height", plotH);
+    block.append("path").attr("class", "pert-scurve-line").attr("d", curve).attr("fill", "none").attr("stroke", palette.colors.red).attr("stroke-width", 2).attr("clip-path", `url(#${clipId})`);
+  }
+  const dots = [
+    {
+      value: data.p50Days,
+      durationDays: data.referenceLines[0]?.durationDays ?? data.p50Days,
+      pct: 0.5,
+      label: "P50",
+      band: "yellow",
+      isPast: data.referenceLines[0]?.isPast ?? false
+    },
+    {
+      value: data.p80Days,
+      durationDays: data.referenceLines[1]?.durationDays ?? data.p80Days,
+      pct: 0.8,
+      label: "P80",
+      band: "orange",
+      isPast: data.referenceLines[1]?.isPast ?? false
+    },
+    {
+      value: data.p95Days,
+      durationDays: data.referenceLines[2]?.durationDays ?? data.p95Days,
+      pct: 0.95,
+      label: "P95",
+      band: "red",
+      isPast: data.referenceLines[2]?.isPast ?? false
+    }
+  ];
+  block.append("style").text(
+    ".pert-scurve-percentile-verbose{opacity:0;pointer-events:none}.pert-scurve-percentile:hover .pert-scurve-percentile-label{opacity:0}.pert-scurve-percentile:hover .pert-scurve-percentile-verbose{opacity:1}"
+  );
+  const dotXs = dots.map((d) => xScale(d.value));
+  for (const d of dots) {
+    const cx = xScale(d.value);
+    const cy = yScale(d.pct);
+    const color = palette.colors[d.band];
+    const valueText = isAnchored ? formatScurveDate(addCalendarDays(data.anchorDate, d.value)) : formatScurveTick(d.durationDays, unit);
+    const inlineText = `${d.label} \xB7 ${valueText}`;
+    const pctInt = Math.round(d.pct * 100);
+    const verboseText = data.mode === "backward" ? `${pctInt}% chance of meeting deadline` : isAnchored ? `${pctInt}% chance to finish by ${valueText}` : `${pctInt}% chance within ${valueText}`;
+    const verboseCharW = SCURVE_TICK_FONT_SIZE * 0.55;
+    const verboseW = verboseText.length * verboseCharW;
+    const inlineGap = SCURVE_PERCENTILE_RADIUS + 6;
+    const roomRight = plotRight - cx - inlineGap;
+    const roomLeft = cx - plotLeft - inlineGap;
+    let labelX;
+    let labelAnchor;
+    if (verboseW <= roomRight) {
+      labelX = cx + inlineGap;
+      labelAnchor = "start";
+    } else if (verboseW <= roomLeft) {
+      labelX = cx - inlineGap;
+      labelAnchor = "end";
+    } else if (roomRight >= roomLeft) {
+      labelX = plotRight;
+      labelAnchor = "end";
+    } else {
+      labelX = plotLeft;
+      labelAnchor = "start";
+    }
+    const labelFill = mix(color, palette.text, 25);
+    const dotGroup = block.append("g").attr("class", "pert-scurve-percentile").attr("data-percentile", d.label);
+    dotGroup.append("line").attr("class", "pert-scurve-percentile-tick").attr("x1", cx).attr("x2", cx).attr("y1", cy).attr("y2", plotBottom).attr("stroke", color).attr("stroke-width", 1).attr("stroke-dasharray", d.isPast ? "4,2" : "3 3").attr("opacity", 0.7);
+    dotGroup.append("circle").attr("class", "pert-scurve-percentile-dot").attr("cx", cx).attr("cy", cy).attr("r", SCURVE_PERCENTILE_RADIUS).attr("fill", color).attr("stroke", fill).attr("stroke-width", 1.5).attr("data-percentile", d.label);
+    dotGroup.append("circle").attr("class", "pert-scurve-percentile-hit").attr("cx", cx).attr("cy", cy).attr("r", 14).attr("fill", "transparent").attr("pointer-events", "all");
+    dotGroup.append("text").attr("class", "pert-scurve-percentile-label").attr("x", labelX).attr("y", cy + SCURVE_TICK_FONT_SIZE / 3).attr("text-anchor", labelAnchor).attr("fill", labelFill).attr("font-size", SCURVE_TICK_FONT_SIZE).attr("font-weight", "700").attr("paint-order", "stroke fill").attr("stroke", fill).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.95).text(inlineText);
+    dotGroup.append("text").attr("class", "pert-scurve-percentile-verbose").attr("x", labelX).attr("y", cy + SCURVE_TICK_FONT_SIZE / 3).attr("text-anchor", labelAnchor).attr("fill", labelFill).attr("font-size", SCURVE_TICK_FONT_SIZE).attr("font-weight", "700").attr("paint-order", "stroke fill").attr("stroke", fill).attr("stroke-width", 3).attr("stroke-linejoin", "round").attr("stroke-opacity", 0.95).text(verboseText);
+  }
+  const N_X_TICKS = isAnchored ? 5 : 6;
+  const LABEL_W_EST = isAnchored ? 48 : 36;
+  const TICK_MIN_GAP = 6;
+  const footprint = (t) => {
+    if (t.anchor === "start") return [t.x, t.x + LABEL_W_EST];
+    if (t.anchor === "end") return [t.x - LABEL_W_EST, t.x];
+    return [t.x - LABEL_W_EST / 2, t.x + LABEL_W_EST / 2];
+  };
+  const all = [];
+  for (let i = 0; i < N_X_TICKS; i++) {
+    const v = xMin + xRange * i / (N_X_TICKS - 1);
+    all.push({
+      v,
+      x: xScale(v),
+      anchor: i === 0 ? "start" : i === N_X_TICKS - 1 ? "end" : "middle"
+    });
+  }
+  const TICK_DOT_PROXIMITY = 28;
+  const collidesWithDot = (t) => dotXs.some((dx) => Math.abs(t.x - dx) < TICK_DOT_PROXIMITY);
+  const kept = [all[0]];
+  const last = all[all.length - 1];
+  const lastLeft = footprint(last)[0];
+  let rightEdge = footprint(all[0])[1];
+  for (let i = 1; i < all.length - 1; i++) {
+    const t = all[i];
+    if (collidesWithDot(t)) continue;
+    const [l, r] = footprint(t);
+    if (r + TICK_MIN_GAP > lastLeft) continue;
+    if (l - TICK_MIN_GAP < rightEdge) continue;
+    kept.push(t);
+    rightEdge = r;
+  }
+  kept.push(last);
+  for (const t of kept) {
+    const labelText = isAnchored ? formatScurveDate(addCalendarDays(data.anchorDate, t.v)) : formatScurveTick(t.v, unit);
+    block.append("text").attr("class", "pert-scurve-xtick").attr("x", t.x).attr("y", plotBottom + SCURVE_TICK_FONT_SIZE + 6).attr("text-anchor", t.anchor).attr("fill", labelColor).attr("font-size", SCURVE_TICK_FONT_SIZE).text(labelText);
+  }
+}
+function formatScurveTick(days, unit) {
+  const value = days / UNIT_TO_DAYS_LOCAL[unit];
+  const display = (Math.round(value * 10) / 10).toFixed(1).replace(/\.0$/, "");
+  return `${display}${unit}`;
+}
+var SCURVE_MONTH_NAMES = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatScurveDate(iso) {
+  const parts = iso.split("-");
+  if (parts.length !== 3) return iso;
+  const month = parseInt(parts[1], 10) - 1;
+  const day = parseInt(parts[2], 10);
+  if (month < 0 || month > 11 || isNaN(day)) return iso;
+  return `${SCURVE_MONTH_NAMES[month]} ${day}`;
+}
+var UNIT_TO_DAYS_LOCAL = {
+  min: 1 / (60 * 24),
+  h: 1 / 24,
+  d: 1,
+  bd: 1,
+  w: 7,
+  m: 30,
+  q: 90,
+  y: 365,
+  s: 14
+};
+
+export {
+  renderPert,
+  renderPertForExport,
+  measurePertAnalysisBlock,
+  renderPertAnalysisBlock
+};
+//# sourceMappingURL=chunk-CI2G3OEB.js.map