@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-G2H74XJZ.js

@@ -0,0 +1,2104 @@
+import {
+  MONTH_ABBR,
+  computeTimeTicks
+} from "./chunk-YRYKTYMQ.js";
+import {
+  renderIntegratedLegend
+} from "./chunk-PWIHZ6NJ.js";
+import {
+  ScaleContext
+} from "./chunk-YYVTBZZC.js";
+import {
+  controlsGroupCapsuleWidth,
+  getMaxLegendReservedHeight
+} from "./chunk-YAA6IID3.js";
+import {
+  TITLE_FONT_SIZE,
+  TITLE_FONT_WEIGHT,
+  TITLE_Y
+} from "./chunk-A4GOY3PE.js";
+import {
+  FONT_FAMILY
+} from "./chunk-6KFWC4CO.js";
+import {
+  LEGEND_CAPSULE_PAD,
+  LEGEND_DOT_R,
+  LEGEND_ENTRY_DOT_GAP,
+  LEGEND_ENTRY_FONT_SIZE,
+  LEGEND_ENTRY_TRAIL,
+  LEGEND_GEAR_PILL_W,
+  LEGEND_GROUP_GAP,
+  LEGEND_HEIGHT,
+  LEGEND_ICON_W,
+  LEGEND_PILL_FONT_SIZE,
+  LEGEND_PILL_PAD,
+  measureLegendText,
+  truncateLegendText
+} from "./chunk-QOOUC2J5.js";
+import {
+  CHAR_WIDTH_RATIO,
+  measureText,
+  truncateText
+} from "./chunk-WCT3NYCV.js";
+import {
+  contrastText,
+  getSeriesColors,
+  mix,
+  shapeFill
+} from "./chunk-P6T66CCZ.js";
+import {
+  resolveActiveTagGroup,
+  resolveTagColor,
+  tagAttrKey
+} from "./chunk-QLCCJEJI.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+
+// src/gantt/renderer.ts
+import * as d3Scale from "d3-scale";
+import * as d3Selection from "d3-selection";
+var BAR_H = 22;
+var ROW_GAP = 6;
+var GROUP_GAP = 14;
+var MILESTONE_SIZE = 10;
+var MIN_LEFT_MARGIN = 120;
+var BOTTOM_MARGIN = 40;
+var RIGHT_MARGIN = 20;
+var LABEL_PAD = 8;
+var LABEL_GAP = 5;
+function computeBarLabel(label, x1, barWidth, innerWidth, textColor, onFillColor, fontSize = 10, labelPad = LABEL_PAD, labelGap = LABEL_GAP) {
+  const textWidth = measureText(label, fontSize);
+  const x2 = x1 + barWidth;
+  if (textWidth < barWidth - labelPad) {
+    return {
+      x: x1 + 6,
+      anchor: "start",
+      fill: onFillColor ?? textColor,
+      text: label
+    };
+  }
+  if (x2 + labelGap + textWidth <= innerWidth) {
+    return { x: x2 + labelGap, anchor: "start", fill: textColor, text: label };
+  }
+  if (x1 - labelGap - textWidth >= 0) {
+    return { x: x1 - labelGap, anchor: "end", fill: textColor, text: label };
+  }
+  const availWidth = x1 - labelGap;
+  if (availWidth > fontSize * CHAR_WIDTH_RATIO * 3) {
+    const truncated = truncateText(label, fontSize, availWidth);
+    if (!truncated) return null;
+    return {
+      x: x1 - labelGap,
+      anchor: "end",
+      fill: textColor,
+      text: truncated
+    };
+  }
+  return null;
+}
+var BAND_ACCENT_W = 4;
+var BAND_RADIUS = 4;
+var bandClipCounter = 0;
+function renderLabelBand(svg, y, leftMargin, color, palette, isDark, cssPrefix, dataAttr, solid, barH = BAR_H, bandRadius = BAND_RADIUS, bandAccentW = BAND_ACCENT_W) {
+  const bandX = 5;
+  const bandW = leftMargin - 7;
+  const bandY = y - barH / 2;
+  const clipId = `gantt-band-clip-${bandClipCounter++}`;
+  svg.append("clipPath").attr("id", clipId).append("rect").attr("x", bandX).attr("y", bandY).attr("width", bandW).attr("height", barH).attr("rx", bandRadius);
+  const tint = svg.append("rect").attr("class", `gantt-${cssPrefix}-band-bg`).attr("x", bandX).attr("y", bandY).attr("width", bandW).attr("height", barH).attr("rx", bandRadius).attr(
+    "fill",
+    shapeFill(palette, color, isDark, {
+      ...solid !== void 0 && { solid }
+    })
+  ).style("pointer-events", "none");
+  const accent = svg.append("rect").attr("class", `gantt-${cssPrefix}-band-accent`).attr("x", bandX).attr("y", bandY).attr("width", bandAccentW).attr("height", barH).attr("fill", color).attr("clip-path", `url(#${clipId})`).style("pointer-events", "none");
+  if (dataAttr) {
+    tint.attr(dataAttr.key, dataAttr.value);
+    accent.attr(dataAttr.key, dataAttr.value);
+  }
+}
+function appendTaskIcon(textEl, label, isMilestone, iconColor, textColor) {
+  const icon = isMilestone ? "\u25C6" : "\u25CF";
+  textEl.append("tspan").attr("fill", iconColor).text(icon);
+  textEl.append("tspan").attr("fill", textColor).text(" " + label);
+}
+function renderGantt(container, resolved, palette, isDark, options, exportDims) {
+  container.innerHTML = "";
+  bandClipCounter = 0;
+  if (resolved.tasks.length === 0) return;
+  const solid = false;
+  const onClickItem = options?.onClickItem;
+  const collapsedGroups = options?.collapsedGroups ?? new Set(resolved.groups.filter((g2) => g2.collapsed).map((g2) => g2.name));
+  const onToggleGroup = options?.onToggleGroup;
+  const viewMode = options?.viewMode ?? false;
+  const currentSwimlaneGroup = options?.currentSwimlaneGroup ?? null;
+  const onSwimlaneChange = options?.onSwimlaneChange;
+  const onActiveGroupChange = options?.onActiveGroupChange;
+  const collapsedLanes = options?.collapsedLanes;
+  const onToggleLane = options?.onToggleLane;
+  const controlsHost = options?.controlsHost ?? "inline";
+  const seriesColors = getSeriesColors(palette);
+  let currentActiveGroup = resolveActiveTagGroup(
+    resolved.tagGroups,
+    resolved.options.activeTag ?? void 0,
+    options?.currentActiveGroup
+  );
+  let criticalPathActive = options?.criticalPathActive ?? false;
+  let dependenciesActive = options?.dependenciesActive ?? false;
+  let controlsExpanded = false;
+  const tagRows = currentSwimlaneGroup ? buildTagLaneRowList(resolved, currentSwimlaneGroup, collapsedLanes) : null;
+  const rows = tagRows ?? buildRowList(resolved, collapsedGroups);
+  const isTagMode = tagRows !== null;
+  const LABEL_FONT = 11;
+  const labelWidths = isTagMode ? [
+    ...rows.filter((r) => r.type === "lane-header").map((r) => measureText(r.laneName, LABEL_FONT)),
+    ...rows.filter((r) => r.type === "task").map((r) => measureText("\u25CF " + r.task.task.label, LABEL_FONT))
+  ] : [
+    ...resolved.tasks.map(
+      (t) => measureText("\u25CF " + t.task.label, LABEL_FONT)
+    ),
+    ...resolved.groups.map((g2) => {
+      const indentPx = g2.depth <= 2 ? g2.depth * 14 : 2 * 14 + (g2.depth - 2) * 8;
+      return indentPx + measureText(g2.name, LABEL_FONT);
+    })
+  ];
+  const maxLabelWidth = Math.max(
+    ...labelWidths,
+    measureText("0000000000", LABEL_FONT)
+  );
+  const leftMargin = Math.max(MIN_LEFT_MARGIN, maxLabelWidth + 30);
+  const totalRows = rows.length;
+  const hasCriticalPath = resolved.options.criticalPath && resolved.tasks.some((t) => t.isCriticalPath);
+  const hasDependencies = resolved.options.dependencies && resolved.tasks.some((t) => t.task.dependencies.length > 0);
+  let resolvedTodayDate = null;
+  if (resolved.options.todayMarker !== "off") {
+    const d = resolved.options.todayMarker === "on" ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(resolved.options.todayMarker + "T00:00:00");
+    if (d >= resolved.startDate && d <= resolved.endDate) {
+      resolvedTodayDate = d;
+    }
+  }
+  const title = resolved.options.title;
+  const showTitle = !!title && !resolved.options.noTitle;
+  const titleHeight = showTitle ? 50 : 20;
+  const containerWidth = exportDims?.width ?? (container.clientWidth || 800);
+  const hasTagLegend = resolved.tagGroups.length > 0 || hasCriticalPath || hasDependencies;
+  const tagLegendReserve = hasTagLegend ? getMaxLegendReservedHeight(
+    {
+      groups: resolved.tagGroups.map((tg) => ({
+        name: tg.name,
+        entries: tg.entries
+      })),
+      position: { placement: "top-center", titleRelation: "below-title" },
+      mode: "preview",
+      capsulePillAddonWidth: LEGEND_ICON_W
+    },
+    containerWidth
+  ) + 8 : 0;
+  const topDateLabelReserve = 22;
+  const HEADER_ROW_H = 18;
+  const eraReserve = resolved.eras.length > 0 ? HEADER_ROW_H : 0;
+  const markerReserve = resolved.markers.length > 0 ? HEADER_ROW_H : 0;
+  const todayReserve = resolvedTodayDate ? HEADER_ROW_H : 0;
+  const sprintLabelReserve = resolved.sprints.length > 0 ? 16 : 0;
+  const CONTENT_TOP_PAD = 16;
+  const idealWidth = leftMargin + totalRows * 20 + RIGHT_MARGIN + 200;
+  const ctx = exportDims ? ScaleContext.identity() : ScaleContext.from(containerWidth, idealWidth);
+  const sBarH = ctx.structural(BAR_H);
+  const sRowGap = ctx.structural(ROW_GAP);
+  const sGroupGap = ctx.structural(GROUP_GAP);
+  const sMilestoneSize = ctx.structural(MILESTONE_SIZE);
+  const sBottomMargin = ctx.aesthetic(BOTTOM_MARGIN);
+  const sRightMargin = ctx.aesthetic(RIGHT_MARGIN);
+  const sLabelPad = ctx.structural(LABEL_PAD);
+  const sLabelGap = ctx.structural(LABEL_GAP);
+  const sBandAccentW = ctx.structural(BAND_ACCENT_W);
+  const sBandRadius = ctx.structural(BAND_RADIUS);
+  const sTitleFontSize = ctx.text(TITLE_FONT_SIZE);
+  const sTitleY = ctx.aesthetic(TITLE_Y);
+  const sHeaderRowH = ctx.structural(HEADER_ROW_H);
+  const sContentTopPad = ctx.aesthetic(CONTENT_TOP_PAD);
+  const sTopDateLabelReserve = ctx.structural(topDateLabelReserve);
+  const sSprintLabelReserve = ctx.structural(sprintLabelReserve);
+  const sTitleHeight = ctx.aesthetic(titleHeight);
+  const sTagLegendReserve = ctx.structural(tagLegendReserve);
+  const sEraReserve = ctx.structural(eraReserve);
+  const sMarkerReserve = ctx.structural(markerReserve);
+  const sTodayReserve = ctx.structural(todayReserve);
+  const sFont10 = ctx.text(10);
+  const sFont11 = ctx.text(11);
+  const sMarginTop = sTitleHeight + sTagLegendReserve + sEraReserve + sMarkerReserve + sTodayReserve + sTopDateLabelReserve + sSprintLabelReserve;
+  const sTodayLabelY = sTodayReserve ? -(sTopDateLabelReserve + sHeaderRowH / 2) : 0;
+  const sMarkerLabelY = sMarkerReserve ? -(sTopDateLabelReserve + sTodayReserve + sHeaderRowH / 2) : 0;
+  const sEraLabelY = sEraReserve ? -(sTopDateLabelReserve + sTodayReserve + sMarkerReserve + sHeaderRowH / 2) : 0;
+  const sContentH = isTagMode ? totalRows * (sBarH + sRowGap) : totalRows * (sBarH + sRowGap) + sGroupGap * resolved.groups.length;
+  const sInnerHeight = sContentTopPad + sContentH;
+  const sOuterHeight = sMarginTop + sInnerHeight + sBottomMargin;
+  const sprintRightPad = resolved.sprints.length > 0 ? 50 : 0;
+  const innerWidth = containerWidth - leftMargin - sRightMargin - sprintRightPad;
+  const svg = d3Selection.select(container).append("svg").attr("viewBox", `0 0 ${containerWidth} ${sOuterHeight}`).attr("width", exportDims ? containerWidth : "100%").attr("preserveAspectRatio", "xMidYMin meet").attr("font-family", FONT_FAMILY).style("overflow", "visible");
+  const g = svg.append("g").attr("transform", `translate(${leftMargin}, ${sMarginTop})`);
+  if (showTitle) {
+    svg.append("text").attr("class", "chart-title").attr("x", containerWidth / 2).attr("y", sTitleY).attr("text-anchor", "middle").attr("font-size", sTitleFontSize).attr("font-weight", TITLE_FONT_WEIGHT).attr("fill", palette.text).text(title);
+  }
+  function drawLegend() {
+    svg.selectAll(".gantt-tag-legend-container").remove();
+    if (resolved.tagGroups.length > 0 || hasCriticalPath || hasDependencies) {
+      const legendY = sTitleHeight;
+      renderTagLegend(
+        svg,
+        g,
+        resolved.tagGroups,
+        currentActiveGroup,
+        leftMargin,
+        innerWidth,
+        legendY,
+        palette,
+        isDark,
+        hasCriticalPath,
+        criticalPathActive,
+        resolved.options.optionLineNumbers,
+        (groupName) => {
+          currentActiveGroup = currentActiveGroup?.toLowerCase() === groupName.toLowerCase() ? null : groupName;
+          if (onActiveGroupChange) onActiveGroupChange(currentActiveGroup);
+          drawLegend();
+          recolorBars();
+        },
+        () => {
+          controlsExpanded = !controlsExpanded;
+          drawLegend();
+        },
+        currentSwimlaneGroup,
+        onSwimlaneChange,
+        viewMode,
+        resolved.tasks,
+        controlsExpanded,
+        hasDependencies,
+        dependenciesActive,
+        (toggleId, active) => {
+          if (toggleId === "critical-path") {
+            criticalPathActive = active;
+            if (active) {
+              applyCriticalPathHighlight(svg, g);
+            } else {
+              svg.attr("data-critical-path-active", null);
+              resetHighlightAll(svg, g);
+            }
+          } else if (toggleId === "dependencies") {
+            dependenciesActive = active;
+            g.selectAll(
+              ".gantt-dep-arrow, .gantt-dep-arrowhead, .gantt-dep-label"
+            ).attr("display", active ? null : "none");
+          }
+          drawLegend();
+        },
+        options?.exportMode ?? false,
+        controlsHost
+      );
+    }
+  }
+  function restoreHighlight() {
+    if (criticalPathActive) {
+      applyCriticalPathHighlight(svg, g);
+    } else {
+      svg.attr("data-critical-path-active", null);
+      resetHighlight(g, svg);
+    }
+  }
+  function recolorBars() {
+    g.selectAll(".gantt-task").each(function() {
+      const el = d3Selection.select(this);
+      const taskId = el.attr("data-task-id");
+      const rt = resolved.tasks.find((t) => t.task.id === taskId);
+      if (!rt) return;
+      const color = resolveTaskColor(
+        rt,
+        currentActiveGroup,
+        resolved,
+        seriesColors,
+        palette
+      );
+      const fillColor = shapeFill(palette, color, isDark, { solid });
+      el.select("rect").attr("fill", fillColor).attr("stroke", color);
+    });
+  }
+  drawLegend();
+  const startTime = dateToFractionalYear(resolved.startDate);
+  const endTime = dateToFractionalYear(resolved.endDate);
+  const domainPad = Math.max((endTime - startTime) * 0.02, 0.01);
+  const domainMin = startTime - domainPad;
+  const domainMax = endTime + domainPad;
+  const xScale = d3Scale.scaleLinear().domain([domainMin, domainMax]).range([0, innerWidth]);
+  renderTimeScaleHorizontal(g, xScale, innerWidth, sInnerHeight, palette.text);
+  renderWeekendBands(g, resolved, xScale, sInnerHeight, palette, isDark);
+  renderHolidayBands(
+    g,
+    svg,
+    resolved,
+    xScale,
+    sInnerHeight,
+    palette,
+    isDark,
+    sMarginTop - 4,
+    leftMargin,
+    onClickItem
+  );
+  renderErasAndMarkers(
+    g,
+    svg,
+    resolved,
+    xScale,
+    sInnerHeight,
+    palette,
+    sEraLabelY,
+    sMarkerLabelY
+  );
+  renderSprintBands(g, svg, resolved, xScale, sInnerHeight, palette);
+  const todayDate = resolvedTodayDate;
+  let todayX = -1;
+  const todayColor = palette.accent || "#e74c3c";
+  const todayMarkerLineNum = resolved.options.optionLineNumbers["today-marker"];
+  if (todayDate) {
+    todayX = xScale(dateToFractionalYear(todayDate));
+    if (todayX >= 0 && todayX <= innerWidth) {
+      const todayLine = g.append("line").attr("class", "gantt-today").attr("x1", todayX).attr("y1", 0).attr("x2", todayX).attr("y2", sInnerHeight + 10).attr("stroke", todayColor).attr("stroke-width", 2).attr("stroke-dasharray", "6 4").attr("opacity", 0.7).attr("pointer-events", "none");
+      if (todayMarkerLineNum)
+        todayLine.attr("data-line-number", String(todayMarkerLineNum));
+      const todayLabel = g.append("text").attr("class", "gantt-today").attr("x", todayX).attr("y", sTodayLabelY).attr("text-anchor", "middle").attr("font-size", `${sFont10}px`).attr("fill", todayColor).attr("opacity", 0.7).attr("pointer-events", "none").text("Today");
+      if (todayMarkerLineNum)
+        todayLabel.attr("data-line-number", String(todayMarkerLineNum));
+    }
+  }
+  const taskPositions = /* @__PURE__ */ new Map();
+  const groupPositions = /* @__PURE__ */ new Map();
+  const lanePositions = /* @__PURE__ */ new Map();
+  const taskLaneMap = /* @__PURE__ */ new Map();
+  if (isTagMode && currentSwimlaneGroup) {
+    const tagGroup = resolved.tagGroups.find(
+      (tg) => tg.name.toLowerCase() === currentSwimlaneGroup.toLowerCase()
+    );
+    if (tagGroup) {
+      const tagKey = tagAttrKey(tagGroup.name);
+      for (const rt of resolved.tasks) {
+        let value = rt.effectiveMetadata[tagKey];
+        if (!value && tagGroup.defaultValue) value = tagGroup.defaultValue;
+        if (value) {
+          const entry = tagGroup.entries.find(
+            (e) => e.value.toLowerCase() === value.toLowerCase()
+          );
+          if (entry) taskLaneMap.set(rt.task.id, entry.value);
+        }
+      }
+    }
+  }
+  let yOffset = sContentTopPad;
+  for (const row of rows) {
+    if (row.type === "lane-header") {
+      const laneColor = row.laneColor === "#999999" ? palette.textMuted : row.laneColor;
+      const toggleIcon = row.isCollapsed ? "\u25B6" : "\u25BC";
+      const labelX = 10;
+      let lx1 = 0;
+      let lx2 = innerWidth;
+      let laneBarWidth = innerWidth;
+      if (row.laneStartDate && row.laneEndDate) {
+        lx1 = xScale(dateToFractionalYear(row.laneStartDate));
+        lx2 = xScale(dateToFractionalYear(row.laneEndDate));
+        laneBarWidth = Math.max(lx2 - lx1, 2);
+      }
+      lanePositions.set(row.laneName, {
+        x1: lx1,
+        x2: lx1 + laneBarWidth,
+        y: yOffset + sBarH / 2
+      });
+      renderLabelBand(
+        svg,
+        sMarginTop + yOffset + sBarH / 2,
+        leftMargin,
+        laneColor,
+        palette,
+        isDark,
+        "lane",
+        { key: "data-lane", value: row.laneName },
+        solid,
+        sBarH,
+        sBandRadius,
+        sBandAccentW
+      );
+      const labelG = svg.append("g").attr("class", "gantt-lane-header").attr(`data-tag-${row.tagKey}`, row.laneName.toLowerCase()).attr("data-lane", row.laneName).style("cursor", onToggleLane ? "pointer" : "default").on("click", () => {
+        if (onToggleLane) onToggleLane(row.laneName);
+      }).on("mouseenter", () => {
+        highlightLane(g, svg, row.tagKey, row.laneName);
+        if (row.laneStartDate && row.laneEndDate) {
+          showGanttDateIndicators(
+            g,
+            xScale,
+            row.laneStartDate,
+            row.laneEndDate,
+            sInnerHeight,
+            laneColor
+          );
+        }
+      }).on("mouseleave", () => {
+        restoreHighlight();
+        hideGanttDateIndicators(g);
+      });
+      labelG.append("text").attr("x", labelX).attr("y", sMarginTop + yOffset + sBarH / 2).attr("dy", "0.35em").attr("text-anchor", "start").attr("font-size", `${sFont11}px`).attr("font-weight", "bold").attr("fill", laneColor).text(
+        toggleIcon + " " + row.laneName + (row.aggregateProgress !== null ? ` ${Math.round(row.aggregateProgress)}%` : "")
+      );
+      if (laneBarWidth > 0) {
+        const barFill = shapeFill(palette, laneColor, isDark, { solid });
+        const laneBandG = g.append("g").attr("class", "gantt-lane-band-group").attr("data-lane", row.laneName).on("mouseenter", () => {
+          highlightLane(g, svg, row.tagKey, row.laneName);
+          if (row.laneStartDate && row.laneEndDate) {
+            showGanttDateIndicators(
+              g,
+              xScale,
+              row.laneStartDate,
+              row.laneEndDate,
+              sInnerHeight,
+              laneColor
+            );
+          }
+        }).on("mouseleave", () => {
+          resetHighlight(g, svg);
+          hideGanttDateIndicators(g);
+        });
+        laneBandG.append("rect").attr("class", "gantt-lane-band").attr("x", lx1).attr("y", yOffset).attr("width", laneBarWidth).attr("height", sBarH).attr("rx", 4).attr("fill", barFill).attr("stroke", laneColor).attr("stroke-width", 2);
+        if (row.aggregateProgress !== null && row.aggregateProgress > 0) {
+          laneBandG.append("rect").attr("class", "gantt-lane-progress").attr("x", lx1).attr("y", yOffset).attr(
+            "width",
+            laneBarWidth * Math.min(row.aggregateProgress / 100, 1)
+          ).attr("height", sBarH).attr("fill", laneColor).attr("opacity", 0.5).attr("pointer-events", "none");
+        }
+      }
+      yOffset += sBarH + sRowGap;
+    } else if (row.type === "group") {
+      const group = row.group;
+      const isCollapsed = collapsedGroups?.has(group.name) ?? false;
+      const toggleIcon = isCollapsed ? "\u25B6" : "\u25BC";
+      const tagColor = resolveTagColor(
+        group.metadata,
+        resolved.tagGroups,
+        currentActiveGroup,
+        true
+      );
+      const groupColor = tagColor && tagColor !== "#999999" ? tagColor : group.color || palette.textMuted;
+      renderLabelBand(
+        svg,
+        sMarginTop + yOffset + sBarH / 2,
+        leftMargin,
+        groupColor,
+        palette,
+        isDark,
+        "group",
+        { key: "data-group", value: group.name },
+        solid,
+        sBarH,
+        sBandRadius,
+        sBandAccentW
+      );
+      const labelG = svg.append("g").attr("class", "gantt-group-label").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).style("cursor", onToggleGroup ? "pointer" : "default").on("click", () => {
+        if (onToggleGroup) onToggleGroup(group.name);
+      }).on("mouseenter", () => {
+        highlightGroup(g, svg, group.name);
+        showGanttDateIndicators(
+          g,
+          xScale,
+          group.startDate,
+          group.endDate,
+          sInnerHeight,
+          groupColor
+        );
+      }).on("mouseleave", () => {
+        resetHighlight(g, svg);
+        hideGanttDateIndicators(g);
+      });
+      const groupIndent = group.depth <= 2 ? group.depth * 14 : 2 * 14 + (group.depth - 2) * 8;
+      const labelX = 10 + groupIndent;
+      labelG.append("text").attr("x", labelX).attr("y", sMarginTop + yOffset + sBarH / 2).attr("dy", "0.35em").attr("text-anchor", "start").attr("font-size", `${sFont11}px`).attr("font-weight", "bold").attr("fill", palette.text).text(
+        toggleIcon + " " + group.name + (group.progress !== null ? ` ${Math.round(group.progress)}%` : "")
+      );
+      const gStart = dateToFractionalYear(group.startDate);
+      const gEnd = dateToFractionalYear(group.endDate);
+      const gx1 = xScale(gStart);
+      const gx2 = xScale(gEnd);
+      if (gx2 > gx1) {
+        if (isCollapsed) {
+          const barWidth = Math.max(gx2 - gx1, 2);
+          const summaryG = g.append("g").attr("class", "gantt-group-summary").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).on("mouseenter", () => {
+            highlightGroup(g, svg, group.name);
+            showGanttDateIndicators(
+              g,
+              xScale,
+              group.startDate,
+              group.endDate,
+              sInnerHeight,
+              groupColor
+            );
+          }).on("mouseleave", () => {
+            resetHighlight(g, svg);
+            hideGanttDateIndicators(g);
+          });
+          summaryG.append("rect").attr("x", gx1).attr("y", yOffset).attr("width", barWidth).attr("height", sBarH).attr("rx", 4).attr("fill", shapeFill(palette, groupColor, isDark, { solid })).attr("stroke", groupColor).attr("stroke-width", 2);
+          if (group.progress !== null && group.progress > 0) {
+            summaryG.append("rect").attr("x", gx1).attr("y", yOffset).attr("width", barWidth * Math.min(group.progress / 100, 1)).attr("height", sBarH).attr("fill", groupColor).attr("opacity", 0.5);
+          }
+          const summaryLabel = group.name + (group.progress !== null ? ` ${Math.round(group.progress)}%` : "");
+          const summaryPlacement = computeBarLabel(
+            summaryLabel,
+            gx1,
+            barWidth,
+            innerWidth,
+            palette.text,
+            contrastText(
+              shapeFill(palette, groupColor, isDark, { solid }),
+              palette.textOnFillLight,
+              palette.textOnFillDark
+            ),
+            sFont10,
+            sLabelPad,
+            sLabelGap
+          );
+          if (summaryPlacement) {
+            summaryG.append("text").attr("x", summaryPlacement.x).attr("y", yOffset + sBarH / 2).attr("dy", "0.35em").attr("font-size", `${sFont10}px`).attr("font-weight", "bold").attr("text-anchor", summaryPlacement.anchor).attr("fill", summaryPlacement.fill).attr("pointer-events", "none").text(summaryPlacement.text);
+          }
+          groupPositions.set(group.name, {
+            x1: gx1,
+            x2: gx1 + barWidth,
+            y: yOffset + sBarH / 2
+          });
+        } else {
+          const groupBarWidth = Math.max(gx2 - gx1, 2);
+          const bandFill = shapeFill(palette, groupColor, isDark, { solid });
+          const groupBarG = g.append("g").attr("class", "gantt-group-bar").attr("data-group", group.name).attr("data-line-number", String(group.lineNumber)).on("mouseenter", () => {
+            highlightGroup(g, svg, group.name);
+            showGanttDateIndicators(
+              g,
+              xScale,
+              group.startDate,
+              group.endDate,
+              sInnerHeight,
+              groupColor
+            );
+          }).on("mouseleave", () => {
+            resetHighlight(g, svg);
+            hideGanttDateIndicators(g);
+          });
+          groupBarG.append("rect").attr("x", gx1).attr("y", yOffset).attr("width", groupBarWidth).attr("height", sBarH).attr("rx", 4).attr("fill", bandFill).attr("stroke", groupColor).attr("stroke-width", 2);
+          if (group.progress !== null && group.progress > 0) {
+            groupBarG.append("rect").attr("class", "gantt-group-progress").attr("x", gx1).attr("y", yOffset).attr("width", groupBarWidth * Math.min(group.progress / 100, 1)).attr("height", sBarH).attr("fill", groupColor).attr("opacity", 0.5);
+          }
+          const expandedLabel = group.name + (group.progress !== null ? ` ${Math.round(group.progress)}%` : "");
+          const expandedPlacement = computeBarLabel(
+            expandedLabel,
+            gx1,
+            groupBarWidth,
+            innerWidth,
+            palette.text,
+            contrastText(
+              shapeFill(palette, groupColor, isDark, { solid }),
+              palette.textOnFillLight,
+              palette.textOnFillDark
+            ),
+            sFont10,
+            sLabelPad,
+            sLabelGap
+          );
+          if (expandedPlacement) {
+            groupBarG.append("text").attr("x", expandedPlacement.x).attr("y", yOffset + sBarH / 2).attr("dy", "0.35em").attr("font-size", `${sFont10}px`).attr("font-weight", "bold").attr("text-anchor", expandedPlacement.anchor).attr("fill", expandedPlacement.fill).attr("pointer-events", "none").text(expandedPlacement.text);
+          }
+        }
+      }
+      yOffset += sBarH + sRowGap;
+    } else if (row.type === "task") {
+      const rt = row.task;
+      const task = rt.task;
+      const barColor = resolveTaskColor(
+        rt,
+        currentActiveGroup,
+        resolved,
+        seriesColors,
+        palette
+      );
+      const depth = rt.groupPath.length;
+      const indent = depth <= 2 ? depth * 14 : 2 * 14 + (depth - 2) * 8;
+      const taskLabelX = isTagMode ? 20 : 6 + indent;
+      const topGroup = rt.groupPath.length > 0 ? rt.groupPath[0] : null;
+      const taskLabel = svg.append("text").attr("class", "gantt-task-label").attr("x", taskLabelX).attr("y", sMarginTop + yOffset + sBarH / 2).attr("dy", "0.35em").attr("text-anchor", "start").attr("font-size", `${sFont11}px`).attr("fill", palette.text).attr("data-line-number", String(task.lineNumber)).attr("data-task-id", task.id).attr("data-group", topGroup).style("cursor", onClickItem ? "pointer" : "default").on("click", () => {
+        if (onClickItem) onClickItem(task.lineNumber);
+      }).on("mouseenter", () => {
+        if (rt.isMilestone) {
+          highlightMilestone(g, svg, task.id);
+        } else {
+          highlightTask(g, svg, task.id);
+        }
+      }).on("mouseleave", () => {
+        resetHighlight(g, svg);
+      });
+      appendTaskIcon(
+        taskLabel,
+        task.label,
+        rt.isMilestone,
+        barColor,
+        palette.text
+      );
+      for (const [key, value] of Object.entries(rt.effectiveMetadata)) {
+        taskLabel.attr(`data-tag-${key}`, value.toLowerCase());
+      }
+      if (rt.isCriticalPath) {
+        taskLabel.attr("data-critical-path", "true");
+      }
+      if (rt.isMilestone) {
+        const mx = xScale(dateToFractionalYear(rt.startDate));
+        const my = yOffset + sBarH / 2;
+        g.append("polygon").attr("class", "gantt-milestone").attr("points", diamondPoints(mx, my, sMilestoneSize)).attr("fill", barColor).attr("stroke", barColor).attr("stroke-width", 1.5).attr("data-line-number", String(task.lineNumber)).attr("data-task-name", task.label).attr("data-task-id", task.id).attr("data-group", topGroup).style("cursor", onClickItem ? "pointer" : "default").on("click", () => {
+          if (onClickItem) onClickItem(task.lineNumber);
+        }).on("mouseenter", () => {
+          highlightMilestone(g, svg, task.id);
+          showGanttDateIndicators(
+            g,
+            xScale,
+            rt.startDate,
+            null,
+            sInnerHeight,
+            barColor
+          );
+          g.append("text").attr("class", "gantt-milestone-hover-label").attr("x", mx - sMilestoneSize - 4).attr("y", my).attr("dy", "0.35em").attr("text-anchor", "end").attr("font-size", `${sFont10}px`).attr("fill", barColor).attr("font-weight", "600").text(task.label);
+        }).on("mouseleave", () => {
+          restoreHighlight();
+          hideGanttDateIndicators(g);
+          g.selectAll(".gantt-milestone-hover-label").remove();
+        });
+        taskPositions.set(task.id, { x1: mx, x2: mx, y: my });
+      } else {
+        const tStart = dateToFractionalYear(rt.startDate);
+        const tEnd = dateToFractionalYear(rt.endDate);
+        const x1 = xScale(tStart);
+        const x2 = xScale(tEnd);
+        const barWidth = Math.max(x2 - x1, 2);
+        const fillColor = shapeFill(palette, barColor, isDark, { solid });
+        const taskG = g.append("g").attr("class", "gantt-task").attr("data-line-number", String(task.lineNumber)).attr("data-task-name", task.label).attr("data-task-id", task.id).attr("data-group", topGroup).style("cursor", onClickItem ? "pointer" : "default").on("click", () => {
+          if (onClickItem) onClickItem(task.lineNumber);
+        }).on("mouseenter", () => {
+          if (resolved.options.dependencies) {
+            highlightDeps(g, svg, task.id, resolved);
+          }
+          highlightTaskLabel(svg, task.lineNumber);
+          showGanttDateIndicators(
+            g,
+            xScale,
+            rt.startDate,
+            rt.endDate,
+            sInnerHeight,
+            barColor
+          );
+        }).on("mouseleave", () => {
+          if (resolved.options.dependencies) {
+            restoreHighlight();
+          }
+          resetTaskLabels(svg);
+          hideGanttDateIndicators(g);
+        });
+        for (const [key, value] of Object.entries(rt.effectiveMetadata)) {
+          taskG.attr(`data-tag-${key}`, value.toLowerCase());
+        }
+        const showUncertainFade = rt.isUncertain && (task.progress === null || task.progress <= 80);
+        let barFill = fillColor;
+        let barStroke = barColor;
+        if (showUncertainFade) {
+          const defs = svg.select("defs").empty() ? svg.append("defs") : svg.select("defs");
+          const fillGradId = `gantt-uncertain-fill-${task.id}`;
+          const fillGrad = defs.append("linearGradient").attr("id", fillGradId).attr("x1", "0").attr("x2", "1").attr("y1", "0").attr("y2", "0");
+          fillGrad.append("stop").attr("offset", "0%").attr("stop-color", fillColor).attr("stop-opacity", 1);
+          fillGrad.append("stop").attr("offset", "50%").attr("stop-color", fillColor).attr("stop-opacity", 1);
+          fillGrad.append("stop").attr("offset", "100%").attr("stop-color", fillColor).attr("stop-opacity", 0);
+          const strokeGradId = `gantt-uncertain-stroke-${task.id}`;
+          const strokeGrad = defs.append("linearGradient").attr("id", strokeGradId).attr("x1", "0").attr("x2", "1").attr("y1", "0").attr("y2", "0");
+          strokeGrad.append("stop").attr("offset", "0%").attr("stop-color", barColor).attr("stop-opacity", 1);
+          strokeGrad.append("stop").attr("offset", "50%").attr("stop-color", barColor).attr("stop-opacity", 1);
+          strokeGrad.append("stop").attr("offset", "100%").attr("stop-color", barColor).attr("stop-opacity", 0);
+          barFill = `url(#${fillGradId})`;
+          barStroke = `url(#${strokeGradId})`;
+        }
+        taskG.append("rect").attr("x", x1).attr("y", yOffset).attr("width", barWidth).attr("height", sBarH).attr("rx", 4).attr("fill", barFill).attr("stroke", barStroke).attr("stroke-width", 2);
+        if (task.progress !== null && task.progress > 0) {
+          const progressWidth = barWidth * Math.min(task.progress / 100, 1);
+          let progressFill = barColor;
+          if (showUncertainFade) {
+            const ratio = barWidth / progressWidth;
+            const fadeStart = Math.min(50 * ratio, 100);
+            const defs = svg.select("defs");
+            const progGradId = `gantt-uncertain-progress-${task.id}`;
+            const progGrad = defs.append("linearGradient").attr("id", progGradId).attr("x1", "0").attr("x2", "1").attr("y1", "0").attr("y2", "0");
+            progGrad.append("stop").attr("offset", "0%").attr("stop-color", barColor).attr("stop-opacity", 1);
+            progGrad.append("stop").attr("offset", `${fadeStart}%`).attr("stop-color", barColor).attr("stop-opacity", 1);
+            progGrad.append("stop").attr("offset", "100%").attr("stop-color", barColor).attr("stop-opacity", 0);
+            progressFill = `url(#${progGradId})`;
+          }
+          taskG.append("rect").attr("class", "gantt-progress").attr("x", x1).attr("y", yOffset).attr("width", progressWidth).attr("height", sBarH).attr("fill", progressFill).attr("opacity", 0.5);
+        }
+        if (rt.isCriticalPath) {
+          taskG.attr("data-critical-path", "true");
+        }
+        const labelPlacement = computeBarLabel(
+          task.label,
+          x1,
+          barWidth,
+          innerWidth,
+          palette.text,
+          contrastText(
+            shapeFill(palette, barColor, isDark, { solid }),
+            palette.textOnFillLight,
+            palette.textOnFillDark
+          ),
+          sFont10,
+          sLabelPad,
+          sLabelGap
+        );
+        if (labelPlacement) {
+          taskG.append("text").attr("x", labelPlacement.x).attr("y", yOffset + sBarH / 2).attr("dy", "0.35em").attr("font-size", `${sFont10}px`).attr("text-anchor", labelPlacement.anchor).attr("fill", labelPlacement.fill).attr("pointer-events", "none").text(labelPlacement.text);
+        }
+        taskPositions.set(task.id, {
+          x1,
+          x2: x1 + barWidth,
+          y: yOffset + sBarH / 2
+        });
+      }
+      yOffset += sBarH + sRowGap;
+    }
+  }
+  if (todayDate && todayX >= 0 && todayX <= innerWidth) {
+    const todayHoverG = g.append("g").attr("class", "gantt-today-hover").style("cursor", "pointer");
+    todayHoverG.append("rect").attr("x", todayX - 10).attr("y", -6).attr("width", 20).attr("height", sInnerHeight + 16).attr("fill", "transparent").attr("pointer-events", "all");
+    const todayDateObj = todayDate;
+    todayHoverG.on("mouseenter", () => {
+      g.selectAll(".gantt-task").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(".gantt-milestone").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(
+        ".gantt-group-bar, .gantt-group-summary"
+      ).attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-task-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(".gantt-era-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(".gantt-marker-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      showGanttDateIndicators(
+        g,
+        xScale,
+        todayDateObj,
+        null,
+        sInnerHeight,
+        todayColor
+      );
+    }).on("mouseleave", () => {
+      resetHighlight(g, svg);
+      hideGanttDateIndicators(g);
+    });
+  }
+  if (resolved.options.dependencies) {
+    renderDependencyArrows(
+      g,
+      resolved,
+      taskPositions,
+      groupPositions,
+      collapsedGroups,
+      palette,
+      isDark,
+      isTagMode,
+      lanePositions,
+      collapsedLanes,
+      taskLaneMap
+    );
+    if (!dependenciesActive) {
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead, .gantt-dep-label"
+      ).attr("display", "none");
+    }
+  }
+}
+var JS_DAY_TO_WEEKDAY = [
+  "sun",
+  "mon",
+  "tue",
+  "wed",
+  "thu",
+  "fri",
+  "sat"
+];
+function renderWeekendBands(g, resolved, xScale, innerHeight, palette, isDark) {
+  const workweek = new Set(resolved.holidays.workweek);
+  const start = new Date(resolved.startDate);
+  start.setDate(start.getDate() - 1);
+  const end = new Date(resolved.endDate);
+  end.setDate(end.getDate() + 1);
+  const current = new Date(start);
+  let bandStart = null;
+  while (current <= end) {
+    const dayName = JS_DAY_TO_WEEKDAY[current.getDay()];
+    const isWeekend = !workweek.has(dayName);
+    if (isWeekend && !bandStart) {
+      bandStart = new Date(current);
+    } else if (!isWeekend && bandStart) {
+      drawBand(
+        g,
+        xScale,
+        bandStart,
+        current,
+        innerHeight,
+        palette,
+        isDark,
+        "gantt-weekend-band",
+        0.04
+      );
+      bandStart = null;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  if (bandStart) {
+    drawBand(
+      g,
+      xScale,
+      bandStart,
+      current,
+      innerHeight,
+      palette,
+      isDark,
+      "gantt-weekend-band",
+      0.04
+    );
+  }
+}
+function renderHolidayBands(g, svg, resolved, xScale, innerHeight, palette, isDark, headerY, chartLeftMargin, onClickItem) {
+  for (const h of resolved.holidays.dates) {
+    const start = /* @__PURE__ */ new Date(h.date + "T00:00:00");
+    const end = new Date(start);
+    end.setDate(end.getDate() + 1);
+    drawHolidayBand(
+      g,
+      svg,
+      xScale,
+      start,
+      end,
+      innerHeight,
+      palette,
+      isDark,
+      h.label,
+      h.lineNumber,
+      headerY,
+      chartLeftMargin,
+      onClickItem
+    );
+  }
+  for (const r of resolved.holidays.ranges) {
+    const start = /* @__PURE__ */ new Date(r.startDate + "T00:00:00");
+    const end = /* @__PURE__ */ new Date(r.endDate + "T00:00:00");
+    end.setDate(end.getDate() + 1);
+    drawHolidayBand(
+      g,
+      svg,
+      xScale,
+      start,
+      end,
+      innerHeight,
+      palette,
+      isDark,
+      r.label,
+      r.lineNumber,
+      headerY,
+      chartLeftMargin,
+      onClickItem
+    );
+  }
+}
+function drawBand(g, xScale, start, end, height, palette, _isDark, className, opacity) {
+  const x1 = xScale(dateToFractionalYear(start));
+  const x2 = xScale(dateToFractionalYear(end));
+  if (x2 <= x1) return;
+  g.append("rect").attr("class", className).attr("x", x1).attr("y", 0).attr("width", x2 - x1).attr("height", height).attr("fill", palette.text).attr("opacity", opacity).attr("pointer-events", "none");
+}
+function drawHolidayBand(g, svg, xScale, start, end, height, palette, _isDark, label, lineNumber, headerY, chartLeftMargin, onClickItem) {
+  const x1 = xScale(dateToFractionalYear(start));
+  const x2 = xScale(dateToFractionalYear(end));
+  if (x2 <= x1) return;
+  const bandW = Math.max(x2 - x1, 4);
+  const baseOpacity = 0.08;
+  const hoverOpacity = 0.18;
+  const bandG = g.append("g").attr("class", "gantt-holiday-band").attr("data-line-number", String(lineNumber)).style("cursor", onClickItem ? "pointer" : "default");
+  const bandRect = bandG.append("rect").attr("x", x1).attr("y", 0).attr("width", bandW).attr("height", height).attr("fill", palette.text).attr("opacity", baseOpacity);
+  const labelX = chartLeftMargin + x1 + bandW / 2;
+  const textLen = measureText(label, 10) + 8;
+  const labelBg = svg.append("rect").attr("class", "gantt-holiday-hover-bg").attr("data-line-number", String(lineNumber)).attr("x", labelX - textLen / 2).attr("y", headerY - 11).attr("width", textLen).attr("height", 14).attr("rx", 3).attr("fill", palette.bg).attr("opacity", 0).attr("pointer-events", "none");
+  const labelText = svg.append("text").attr("class", "gantt-holiday-hover-label").attr("data-line-number", String(lineNumber)).attr("x", labelX).attr("y", headerY).attr("text-anchor", "middle").attr("font-size", "10px").attr("font-weight", "500").attr("fill", palette.text).attr("opacity", 0).attr("pointer-events", "none").text(label);
+  bandG.on("mouseenter", () => {
+    bandRect.attr("opacity", hoverOpacity);
+    labelBg.attr("opacity", 1);
+    labelText.attr("opacity", 1);
+    showGanttDateIndicators(g, xScale, start, end, height, palette.textMuted);
+  }).on("mouseleave", () => {
+    bandRect.attr("opacity", baseOpacity);
+    labelBg.attr("opacity", 0);
+    labelText.attr("opacity", 0);
+    hideGanttDateIndicators(g);
+  }).on("click", () => {
+    if (onClickItem) onClickItem(lineNumber);
+  });
+}
+function findCollapsedGroupPos(rt, collapsedGroups, groupPositions) {
+  if (!collapsedGroups) return void 0;
+  for (const groupName of rt.groupPath) {
+    if (collapsedGroups.has(groupName)) {
+      return groupPositions.get(groupName);
+    }
+  }
+  return void 0;
+}
+function findCollapsedLanePos(rt, collapsedLanes, taskLaneMap, lanePositions) {
+  if (!collapsedLanes) return void 0;
+  const laneName = taskLaneMap.get(rt.task.id);
+  if (laneName && collapsedLanes.has(laneName)) {
+    return lanePositions.get(laneName);
+  }
+  return void 0;
+}
+function renderDependencyArrows(g, resolved, taskPositions, groupPositions, collapsedGroups, palette, _isDark, isTagMode, lanePositions, collapsedLanes, taskLaneMap) {
+  const drawnArrows = /* @__PURE__ */ new Set();
+  for (const rt of resolved.tasks) {
+    const sourcePos = taskPositions.get(rt.task.id) ?? (isTagMode ? findCollapsedLanePos(rt, collapsedLanes, taskLaneMap, lanePositions) : findCollapsedGroupPos(rt, collapsedGroups, groupPositions));
+    if (!sourcePos) continue;
+    for (const dep of rt.task.dependencies) {
+      const depKey = normalizeName(dep.targetName);
+      const targetTask = resolved.tasks.find(
+        (t) => normalizeName(t.task.label) === depKey || normalizeName(`${t.groupPath.join(".")}.${t.task.label}`).endsWith(
+          depKey
+        )
+      );
+      if (!targetTask) continue;
+      const targetPos = taskPositions.get(targetTask.task.id) ?? (isTagMode ? findCollapsedLanePos(
+        targetTask,
+        collapsedLanes,
+        taskLaneMap,
+        lanePositions
+      ) : findCollapsedGroupPos(targetTask, collapsedGroups, groupPositions));
+      if (!targetPos) continue;
+      if (sourcePos === targetPos) continue;
+      const arrowKey = `${sourcePos.x1},${sourcePos.y}->${targetPos.x1},${targetPos.y}`;
+      if (drawnArrows.has(arrowKey)) continue;
+      drawnArrows.add(arrowKey);
+      const sx = sourcePos.x2;
+      const sy = sourcePos.y;
+      const tx = targetPos.x1;
+      const ty = targetPos.y;
+      const dx = Math.abs(tx - sx);
+      const dy = Math.abs(ty - sy);
+      const cpOffset = Math.max(dx * 0.3, 15, dy * 0.4);
+      const path = `M ${sx} ${sy} C ${sx + cpOffset} ${sy}, ${tx - cpOffset} ${ty}, ${tx} ${ty}`;
+      const arrowColor = mix(palette.text, palette.bg, 50);
+      const isCpArrow = rt.isCriticalPath && targetTask.isCriticalPath;
+      g.append("path").attr("class", "gantt-dep-arrow").attr("data-dep-from", rt.task.id).attr("data-dep-to", targetTask.task.id).attr("data-line-number", String(dep.lineNumber)).attr("data-critical-path", isCpArrow ? "true" : null).attr("d", path).attr("fill", "none").attr("stroke", arrowColor).attr("stroke-width", 1.5).attr("opacity", 0.5);
+      const headSize = 5;
+      const angle = 0;
+      g.append("polygon").attr("class", "gantt-dep-arrowhead").attr("data-dep-from", rt.task.id).attr("data-dep-to", targetTask.task.id).attr("data-line-number", String(dep.lineNumber)).attr("data-critical-path", isCpArrow ? "true" : null).attr("points", arrowheadPoints(tx, ty, headSize, angle)).attr("fill", arrowColor).attr("opacity", 0.5);
+      if (dep.label) {
+        const midX = (sx + tx) / 2;
+        const midY = (sy + ty) / 2;
+        const labelEl = g.append("text").attr("class", "gantt-dep-label").attr("data-dep-from", rt.task.id).attr("data-dep-to", targetTask.task.id).attr("x", midX).attr("y", midY - 4).attr("text-anchor", "middle").attr("font-size", 10).attr("font-family", FONT_FAMILY).attr("fill", palette.text).attr("opacity", 0.7).text(dep.label);
+        const bbox = labelEl.node()?.getBBox?.();
+        if (bbox && bbox.width > 0) {
+          g.insert("rect", ".gantt-dep-label:last-of-type").attr("class", "gantt-dep-label-bg").attr("x", bbox.x - 2).attr("y", bbox.y - 1).attr("width", bbox.width + 4).attr("height", bbox.height + 2).attr("fill", palette.bg).attr("opacity", 0.8).attr("rx", 2);
+        }
+      }
+    }
+  }
+}
+function arrowheadPoints(x, y, size, angle) {
+  const a1 = angle + Math.PI * 0.8;
+  const a2 = angle - Math.PI * 0.8;
+  return `${x},${y} ${x + size * Math.cos(a1)},${y + size * Math.sin(a1)} ${x + size * Math.cos(a2)},${y + size * Math.sin(a2)}`;
+}
+function applyCriticalPathHighlight(svg, chartG) {
+  svg.attr("data-critical-path-active", "true");
+  chartG.selectAll(".gantt-task").each(function() {
+    const el = d3Selection.select(this);
+    el.attr(
+      "opacity",
+      el.attr("data-critical-path") === "true" ? 1 : FADE_OPACITY
+    );
+  });
+  chartG.selectAll(".gantt-milestone").attr("opacity", FADE_OPACITY);
+  chartG.selectAll(".gantt-group-bar, .gantt-group-summary").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr(
+      "opacity",
+      el.attr("data-critical-path") === "true" ? 1 : FADE_OPACITY
+    );
+  });
+  svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", FADE_OPACITY);
+  chartG.selectAll(".gantt-lane-band, .gantt-lane-accent").attr("opacity", FADE_OPACITY);
+  chartG.selectAll(".gantt-dep-arrow, .gantt-dep-arrowhead").each(function() {
+    const el = d3Selection.select(this);
+    el.attr(
+      "opacity",
+      el.attr("data-critical-path") === "true" ? 0.7 : FADE_OPACITY
+    );
+  });
+}
+function resetHighlightAll(svg, chartG) {
+  chartG.selectAll(".gantt-task, .gantt-milestone").attr("opacity", 1);
+  chartG.selectAll(".gantt-group-bar, .gantt-group-summary").attr("opacity", 1);
+  svg.selectAll(".gantt-task-label").attr("opacity", 1);
+  svg.selectAll(".gantt-group-label").attr("opacity", 1);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", 1);
+  svg.selectAll(".gantt-lane-header").attr("opacity", 1);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", 1);
+  chartG.selectAll(".gantt-lane-band, .gantt-lane-accent").attr("opacity", 1);
+  chartG.selectAll(".gantt-dep-arrow, .gantt-dep-arrowhead").attr("opacity", 0.5);
+}
+function drawSwimlaneIcon(parent, x, y, isActive, palette) {
+  const iconG = parent.append("g").attr("class", "gantt-swimlane-icon").attr("transform", `translate(${x}, ${y})`);
+  iconG.append("rect").attr("x", -5).attr("y", -5).attr("width", 22).attr("height", 18).attr("fill", "transparent");
+  const color = isActive ? palette.primary : palette.textMuted;
+  const opacity = isActive ? 1 : 0.35;
+  const barWidths = [8, 12, 6];
+  const barH = 2;
+  const gap = 3;
+  for (let i = 0; i < barWidths.length; i++) {
+    iconG.append("rect").attr("x", 0).attr("y", i * gap).attr("width", barWidths[i]).attr("height", barH).attr("rx", 1).attr("fill", color).attr("opacity", opacity);
+  }
+  return iconG;
+}
+function buildControlsToggles(hasCriticalPath, criticalPathActive, hasDependencies, dependenciesActive) {
+  const toggles = [];
+  if (hasCriticalPath) {
+    toggles.push({
+      id: "critical-path",
+      type: "toggle",
+      label: "Critical Path",
+      active: criticalPathActive,
+      onToggle: () => {
+      }
+    });
+  }
+  if (hasDependencies) {
+    toggles.push({
+      id: "dependencies",
+      type: "toggle",
+      label: "Dependencies",
+      active: dependenciesActive,
+      onToggle: () => {
+      }
+    });
+  }
+  return toggles;
+}
+function renderTagLegend(svg, chartG, tagGroups, activeGroupName, chartLeftMargin, chartInnerWidth, legendY, palette, isDark, hasCriticalPath, criticalPathActive, _optionLineNumbers, onToggle, onToggleControlsExpand, currentSwimlaneGroup, onSwimlaneChange, legendViewMode, resolvedTasks, controlsExpanded = false, hasDependencies = false, dependenciesActive = false, onControlsToggle, exportMode = false, controlsHost = "inline") {
+  let visibleGroups;
+  if (activeGroupName) {
+    const activeGroup = tagGroups.filter(
+      (g) => g.name.toLowerCase() === activeGroupName.toLowerCase()
+    );
+    const swimlaneGroup = currentSwimlaneGroup && currentSwimlaneGroup.toLowerCase() !== activeGroupName.toLowerCase() ? tagGroups.filter(
+      (g) => g.name.toLowerCase() === currentSwimlaneGroup.toLowerCase()
+    ) : [];
+    visibleGroups = [...swimlaneGroup, ...activeGroup];
+  } else {
+    visibleGroups = tagGroups;
+  }
+  const usedValues = /* @__PURE__ */ new Map();
+  if (resolvedTasks) {
+    for (const group of visibleGroups) {
+      const key = tagAttrKey(group.name);
+      const used = /* @__PURE__ */ new Set();
+      for (const rt of resolvedTasks) {
+        const val = rt.effectiveMetadata[key];
+        if (val) used.add(val.toLowerCase());
+      }
+      usedValues.set(key, used);
+    }
+  }
+  const filteredEntries = /* @__PURE__ */ new Map();
+  for (const group of visibleGroups) {
+    const key = tagAttrKey(group.name);
+    const used = usedValues.get(key);
+    if (used && used.size > 0) {
+      filteredEntries.set(
+        key,
+        group.entries.filter((e) => used.has(e.value.toLowerCase()))
+      );
+    } else {
+      filteredEntries.set(key, group.entries);
+    }
+  }
+  const groupWidths = [];
+  let totalW = 0;
+  for (const group of visibleGroups) {
+    const isActive = activeGroupName?.toLowerCase() === group.name.toLowerCase();
+    const isSwimlane = currentSwimlaneGroup?.toLowerCase() === group.name.toLowerCase();
+    const showIcon = !legendViewMode && tagGroups.length > 0;
+    const iconReserve = showIcon && isActive ? LEGEND_ICON_W : 0;
+    const pillW = measureLegendText(group.name, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD + iconReserve;
+    let groupW = pillW;
+    if (isActive) {
+      const entries = filteredEntries.get(tagAttrKey(group.name)) ?? group.entries;
+      let entriesW = 0;
+      for (const entry of entries) {
+        entriesW += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + measureLegendText(entry.value, LEGEND_ENTRY_FONT_SIZE) + LEGEND_ENTRY_TRAIL;
+      }
+      groupW = LEGEND_CAPSULE_PAD * 2 + pillW + 4 + entriesW;
+    } else if (isSwimlane && !isActive) {
+      groupW = pillW;
+    }
+    groupWidths.push(groupW);
+    totalW += groupW;
+  }
+  totalW += Math.max(0, (visibleGroups.length - 1) * LEGEND_GROUP_GAP);
+  const hasControls = hasCriticalPath || hasDependencies;
+  const controlsToggleLabels = [];
+  if (hasCriticalPath) controlsToggleLabels.push({ label: "Critical Path" });
+  if (hasDependencies) controlsToggleLabels.push({ label: "Dependencies" });
+  if (hasControls) {
+    if (visibleGroups.length > 0) totalW += LEGEND_GROUP_GAP;
+    totalW += controlsExpanded ? controlsGroupCapsuleWidth(controlsToggleLabels) : LEGEND_GEAR_PILL_W;
+  }
+  const containerWidth = chartLeftMargin + chartInnerWidth + RIGHT_MARGIN;
+  const legendX = (containerWidth - totalW) / 2;
+  const legendRow = svg.append("g").attr("class", "gantt-tag-legend-container").attr("transform", `translate(${legendX}, ${legendY})`);
+  if (visibleGroups.length > 0) {
+    const showIcon = !legendViewMode && tagGroups.length > 0;
+    const iconReserve = showIcon ? LEGEND_ICON_W : 0;
+    const legendGroups = visibleGroups.map((g) => {
+      const key = g.name.toLowerCase();
+      const entries = filteredEntries.get(key) ?? g.entries;
+      return {
+        name: g.name,
+        entries: entries.map((e) => ({ value: e.value, color: e.color }))
+      };
+    });
+    const controlsToggles = buildControlsToggles(
+      hasCriticalPath,
+      criticalPathActive,
+      hasDependencies,
+      dependenciesActive
+    );
+    let tagGroupsW = (
+      // In-bounds: groupWidths has one entry per visibleGroups item.
+      visibleGroups.reduce((s, _, i) => s + groupWidths[i], 0) + Math.max(0, (visibleGroups.length - 1) * LEGEND_GROUP_GAP)
+    );
+    if (hasControls) {
+      if (visibleGroups.length > 0) tagGroupsW += LEGEND_GROUP_GAP;
+      tagGroupsW += controlsExpanded ? controlsGroupCapsuleWidth(controlsToggleLabels) : LEGEND_GEAR_PILL_W;
+    }
+    const tagGroupG = legendRow.append("g");
+    const legendCallbacks = {
+      ...onToggle !== void 0 && { onGroupToggle: onToggle },
+      ...onToggleControlsExpand !== void 0 && {
+        onControlsExpand: onToggleControlsExpand
+      },
+      ...onControlsToggle !== void 0 && { onControlsToggle },
+      onEntryHover: (groupName, entryValue) => {
+        const tagKey = tagAttrKey(groupName);
+        if (entryValue) {
+          const ev = entryValue.toLowerCase();
+          chartG.selectAll(".gantt-task").each(function() {
+            const el = d3Selection.select(this);
+            el.attr(
+              "opacity",
+              el.attr(`data-tag-${tagKey}`) === ev ? 1 : FADE_OPACITY
+            );
+          });
+          chartG.selectAll(".gantt-milestone").attr("opacity", FADE_OPACITY);
+          chartG.selectAll(".gantt-group-bar, .gantt-group-summary").attr("opacity", FADE_OPACITY);
+          svg.selectAll(".gantt-task-label").each(function() {
+            const el = d3Selection.select(this);
+            el.attr(
+              "opacity",
+              el.attr(`data-tag-${tagKey}`) === ev ? 1 : FADE_OPACITY
+            );
+          });
+          svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+          svg.selectAll(".gantt-lane-header").each(function() {
+            const el = d3Selection.select(this);
+            el.attr(
+              "opacity",
+              el.attr(`data-tag-${tagKey}`) === ev ? 1 : FADE_OPACITY
+            );
+          });
+          chartG.selectAll(".gantt-lane-band, .gantt-lane-accent").attr("opacity", FADE_OPACITY);
+        } else {
+          if (criticalPathActive) {
+            applyCriticalPathHighlight(svg, chartG);
+          } else {
+            resetHighlightAll(svg, chartG);
+          }
+        }
+      },
+      onGroupRendered: (groupName, groupEl, _isActive) => {
+        const group = visibleGroups.find((g) => g.name === groupName);
+        if (group) {
+          groupEl.attr("data-tag-group", group.name).attr("data-line-number", String(group.lineNumber));
+        }
+        if (showIcon && _isActive) {
+          const isSwimlane = currentSwimlaneGroup?.toLowerCase() === groupName.toLowerCase();
+          const textW = measureLegendText(groupName, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
+          const pillXOff = LEGEND_CAPSULE_PAD;
+          const iconX = pillXOff + textW + 3;
+          const iconY = (LEGEND_HEIGHT - 10) / 2;
+          const iconEl = drawSwimlaneIcon(
+            groupEl,
+            iconX,
+            iconY,
+            isSwimlane,
+            palette
+          );
+          iconEl.append("title").text(`Group by ${groupName}`);
+          iconEl.style("cursor", "pointer").on("click", (event) => {
+            event.stopPropagation();
+            if (onSwimlaneChange) {
+              onSwimlaneChange(
+                currentSwimlaneGroup?.toLowerCase() === groupName.toLowerCase() ? null : groupName
+              );
+            }
+          });
+        }
+      }
+    };
+    renderIntegratedLegend(tagGroupG, {
+      groups: legendGroups,
+      palette,
+      isDark,
+      width: tagGroupsW,
+      mode: exportMode ? "export" : "preview",
+      capsulePillAddonWidth: iconReserve,
+      ...controlsToggles.length > 0 && {
+        controlsGroup: { toggles: controlsToggles }
+      },
+      // 'app' suppresses the inline gear so the desktop ControlsStrip hosts the
+      // Critical Path / Dependencies toggles instead (export keeps inline).
+      ...controlsHost === "app" && !exportMode && { controlsHost: "app" },
+      activeGroup: activeGroupName,
+      controlsExpanded,
+      callbacks: legendCallbacks
+    });
+  } else if (hasControls) {
+    const controlsToggles = buildControlsToggles(
+      hasCriticalPath,
+      criticalPathActive,
+      hasDependencies,
+      dependenciesActive
+    );
+    const tagGroupG = legendRow.append("g");
+    renderIntegratedLegend(tagGroupG, {
+      groups: [],
+      palette,
+      isDark,
+      width: totalW,
+      mode: exportMode ? "export" : "preview",
+      controlsGroup: { toggles: controlsToggles },
+      ...controlsHost === "app" && !exportMode && { controlsHost: "app" },
+      activeGroup: null,
+      controlsExpanded,
+      callbacks: {
+        ...onToggleControlsExpand !== void 0 && {
+          onControlsExpand: onToggleControlsExpand
+        },
+        ...onControlsToggle !== void 0 && { onControlsToggle }
+      }
+    });
+  }
+  if (criticalPathActive) {
+    applyCriticalPathHighlight(svg, chartG);
+  }
+}
+var ERA_COLORS = ["#3b6ea5", "#5b9357", "#c9a227", "#cc7a33", "#7d5ba6"];
+function renderErasAndMarkers(g, svg, resolved, xScale, innerHeight, palette, eraLabelY, markerLabelY) {
+  for (let i = 0; i < resolved.eras.length; i++) {
+    const era = resolved.eras[i];
+    if (!era) continue;
+    const color = era.color || ERA_COLORS[i % ERA_COLORS.length];
+    const sx = xScale(parseDateToFractionalYear(era.startDate));
+    const ex = xScale(parseDateToFractionalYear(era.endDate));
+    if (ex <= sx) continue;
+    const baseEraOpacity = 0.08;
+    const hoverEraOpacity = 0.16;
+    const eraStartDate = parseDateStringToDate(era.startDate);
+    const eraEndDate = parseDateStringToDate(era.endDate);
+    const eraG = g.append("g").attr("class", "gantt-era-group").attr("data-line-number", String(era.lineNumber));
+    const eraRect = eraG.append("rect").attr("class", "gantt-era").attr("x", sx).attr("y", 0).attr("width", ex - sx).attr("height", innerHeight).attr("fill", color).attr("opacity", baseEraOpacity);
+    const eraLabelMaxW = Math.max(0, ex - sx - 8);
+    const eraDisplayLabel = truncateLegendText(era.label, 10, eraLabelMaxW);
+    const eraTruncated = eraDisplayLabel !== era.label;
+    const eraLabel = eraG.append("text").attr("class", "gantt-era-label").attr("x", (sx + ex) / 2).attr("y", eraLabelY).attr("text-anchor", "middle").attr("font-size", "10px").attr("fill", color).attr("opacity", 0.7).style("cursor", "pointer").text(eraDisplayLabel);
+    eraG.on("mouseenter", () => {
+      g.selectAll(".gantt-task").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(".gantt-milestone").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(
+        ".gantt-group-bar, .gantt-group-summary"
+      ).attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-task-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(".gantt-marker-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      eraRect.attr("opacity", hoverEraOpacity);
+      if (eraTruncated) eraLabel.text(era.label);
+      showGanttDateIndicators(
+        g,
+        xScale,
+        eraStartDate,
+        eraEndDate,
+        innerHeight,
+        color
+      );
+    }).on("mouseleave", () => {
+      resetHighlight(g, svg);
+      eraRect.attr("opacity", baseEraOpacity);
+      if (eraTruncated) eraLabel.text(eraDisplayLabel);
+      hideGanttDateIndicators(g);
+    });
+  }
+  const markerXs = resolved.markers.map(
+    (m) => xScale(parseDateToFractionalYear(m.date))
+  );
+  const innerWidth = xScale.range()[1];
+  for (let i = 0; i < resolved.markers.length; i++) {
+    const marker = resolved.markers[i];
+    if (!marker) continue;
+    const color = marker.color || palette.accent || "#3a9188";
+    const mx = markerXs[i];
+    const markerDate = parseDateStringToDate(marker.date);
+    const diamondSize = 5;
+    const labelY = markerLabelY;
+    const diamondY = -2;
+    let nearestDist = Math.min(mx, innerWidth - mx);
+    for (let j = 0; j < markerXs.length; j++) {
+      if (j === i) continue;
+      const d = Math.abs(markerXs[j] - mx);
+      if (d < nearestDist) nearestDist = d;
+    }
+    const markerLabelMaxW = Math.max(0, nearestDist - 8);
+    const markerDisplayLabel = truncateLegendText(
+      marker.label,
+      11,
+      markerLabelMaxW
+    );
+    const markerTruncated = markerDisplayLabel !== marker.label;
+    const markerG = g.append("g").attr("class", "gantt-marker-group").attr("data-line-number", String(marker.lineNumber)).style("cursor", "pointer");
+    markerG.append("rect").attr("x", mx - 40).attr("y", labelY - 12).attr("width", 80).attr("height", innerHeight - labelY + 12).attr("fill", "transparent").attr("pointer-events", "all");
+    const markerLabelEl = markerG.append("text").attr("class", "gantt-marker-label").attr("x", mx).attr("y", labelY).attr("text-anchor", "middle").attr("font-size", "11px").attr("font-weight", "600").attr("fill", color).text(markerDisplayLabel);
+    markerG.append("path").attr(
+      "d",
+      `M${mx},${diamondY - diamondSize} l${diamondSize},${diamondSize} l-${diamondSize},${diamondSize} l-${diamondSize},-${diamondSize} Z`
+    ).attr("fill", color).attr("opacity", 0.9);
+    markerG.append("line").attr("class", "gantt-marker").attr("x1", mx).attr("y1", diamondY + diamondSize).attr("x2", mx).attr("y2", innerHeight).attr("stroke", color).attr("stroke-width", 1.5).attr("stroke-dasharray", "6 4").attr("opacity", 0.5);
+    const markerLine = markerG.select(".gantt-marker");
+    const markerDiamond = markerG.select("path");
+    markerG.on("mouseenter", () => {
+      g.selectAll(".gantt-task").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(".gantt-milestone").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(
+        ".gantt-group-bar, .gantt-group-summary"
+      ).attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-task-label").attr("opacity", FADE_OPACITY);
+      svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(".gantt-era-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      g.selectAll(".gantt-marker-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      markerG.attr("opacity", 1);
+      markerLine.attr("opacity", 0.8);
+      markerDiamond.attr("opacity", 0);
+      if (markerTruncated) markerLabelEl.text(marker.label);
+      showGanttDateIndicators(
+        g,
+        xScale,
+        markerDate,
+        null,
+        innerHeight,
+        color,
+        { skipStartLine: true }
+      );
+    }).on("mouseleave", () => {
+      resetHighlight(g, svg);
+      markerLine.attr("opacity", 0.5);
+      markerDiamond.attr("opacity", 0.9);
+      if (markerTruncated) markerLabelEl.text(markerDisplayLabel);
+      hideGanttDateIndicators(g);
+    });
+  }
+}
+var SPRINT_BAND_OPACITY = 0.05;
+var SPRINT_HOVER_OPACITY = 0.12;
+var SPRINT_BOUNDARY_OPACITY = 0.3;
+function renderSprintBands(g, svg, resolved, xScale, innerHeight, palette) {
+  if (resolved.sprints.length === 0) return;
+  if (resolved.eras.length > 0) return;
+  const bandColor = palette.textMuted || palette.text || "#888";
+  const chartMinX = 0;
+  for (let i = 0; i < resolved.sprints.length; i++) {
+    const sprint = resolved.sprints[i];
+    if (!sprint) continue;
+    const rawSx = xScale(dateToFractionalYear(sprint.startDate));
+    const rawEx = xScale(dateToFractionalYear(sprint.endDate));
+    if (rawEx <= rawSx) continue;
+    const sx = Math.max(rawSx, chartMinX);
+    const ex = rawEx;
+    const bandWidth = ex - sx;
+    if (bandWidth <= 0) continue;
+    const sprintG = g.append("g").attr("class", "gantt-sprint-group").style("cursor", "pointer");
+    const sprintRect = sprintG.append("rect").attr("class", "gantt-sprint-band").attr("x", sx).attr("y", 0).attr("width", bandWidth).attr("height", innerHeight).attr("fill", bandColor).attr("opacity", sprint.number % 2 === 0 ? SPRINT_BAND_OPACITY : 0);
+    if (sprint.number % 2 !== 0) {
+      sprintG.append("rect").attr("x", sx).attr("y", 0).attr("width", bandWidth).attr("height", innerHeight).attr("fill", "transparent");
+    }
+    const sprintLabel = sprintG.append("text").attr("class", "gantt-sprint-label").attr("x", (sx + ex) / 2).attr("y", -22).attr("text-anchor", "middle").attr("font-size", "10px").attr("font-weight", "600").attr("fill", bandColor).attr("opacity", 0.4).text(String(sprint.number));
+    if (i > 0 && rawSx >= chartMinX) {
+      sprintG.append("line").attr("class", "gantt-sprint-boundary").attr("x1", sx).attr("y1", -6).attr("x2", sx).attr("y2", innerHeight).attr("stroke", bandColor).attr("stroke-width", 1).attr("stroke-dasharray", "3 3").attr("opacity", SPRINT_BOUNDARY_OPACITY);
+    }
+    const sprintStartMs = sprint.startDate.getTime();
+    const sprintEndMs = sprint.endDate.getTime();
+    const overlappingTaskIds = /* @__PURE__ */ new Set();
+    for (const rt of resolved.tasks) {
+      const taskStart = rt.startDate.getTime();
+      const taskEnd = rt.endDate.getTime();
+      if (taskStart < sprintEndMs && taskEnd > sprintStartMs) {
+        overlappingTaskIds.add(rt.task.id);
+      }
+      if (taskStart === taskEnd && taskStart >= sprintStartMs && taskStart < sprintEndMs) {
+        overlappingTaskIds.add(rt.task.id);
+      }
+    }
+    const overlappingGroupNames = /* @__PURE__ */ new Set();
+    for (const rg of resolved.groups) {
+      const gStart = rg.startDate.getTime();
+      const gEnd = rg.endDate.getTime();
+      if (gStart < sprintEndMs && gEnd > sprintStartMs) {
+        overlappingGroupNames.add(rg.name);
+      }
+    }
+    const baseOpacity = sprint.number % 2 === 0 ? SPRINT_BAND_OPACITY : 0;
+    sprintG.on("mouseenter", () => {
+      g.selectAll(".gantt-task").each(function() {
+        const el = d3Selection.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      g.selectAll(".gantt-milestone").each(function() {
+        const el = d3Selection.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-task-label").each(function() {
+        const el = d3Selection.select(this);
+        const id = el.attr("data-task-id");
+        el.attr(
+          "opacity",
+          id && overlappingTaskIds.has(id) ? 1 : FADE_OPACITY
+        );
+      });
+      g.selectAll(
+        ".gantt-group-bar, .gantt-group-summary"
+      ).each(function() {
+        const el = d3Selection.select(this);
+        const name = el.attr("data-group");
+        el.attr(
+          "opacity",
+          name && overlappingGroupNames.has(name) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-group-label").each(function() {
+        const el = d3Selection.select(this);
+        const name = el.attr("data-group");
+        el.attr(
+          "opacity",
+          name && overlappingGroupNames.has(name) ? 1 : FADE_OPACITY
+        );
+      });
+      svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(
+        ".gantt-dep-arrow, .gantt-dep-arrowhead"
+      ).attr("opacity", FADE_OPACITY);
+      g.selectAll(".gantt-marker-group").attr(
+        "opacity",
+        FADE_OPACITY
+      );
+      sprintRect.attr("opacity", SPRINT_HOVER_OPACITY);
+      const startVisible = rawSx >= chartMinX;
+      if (startVisible) {
+        showGanttDateIndicators(
+          g,
+          xScale,
+          sprint.startDate,
+          sprint.endDate,
+          innerHeight,
+          bandColor
+        );
+      } else {
+        showGanttDateIndicators(
+          g,
+          xScale,
+          sprint.endDate,
+          null,
+          innerHeight,
+          bandColor
+        );
+      }
+      const accentColor = palette.accent || palette.text || bandColor;
+      sprintLabel.text(`Sprint ${sprint.number}`).attr("font-size", "13px").attr("font-weight", "700").attr("fill", accentColor).attr("opacity", 1);
+    }).on("mouseleave", () => {
+      resetHighlight(g, svg);
+      sprintRect.attr("opacity", baseOpacity);
+      sprintLabel.text(String(sprint.number)).attr("font-size", "10px").attr("font-weight", "600").attr("fill", bandColor).attr("opacity", 0.4);
+      hideGanttDateIndicators(g);
+    });
+  }
+  const lastSprint = resolved.sprints[resolved.sprints.length - 1];
+  const lastEx = xScale(dateToFractionalYear(lastSprint.endDate));
+  g.append("line").attr("class", "gantt-sprint-boundary").attr("x1", lastEx).attr("y1", -6).attr("x2", lastEx).attr("y2", innerHeight).attr("stroke", bandColor).attr("stroke-width", 1).attr("stroke-dasharray", "3 3").attr("opacity", SPRINT_BOUNDARY_OPACITY);
+}
+function parseDateStringToDate(s) {
+  const parts = s.split("-").map((p) => parseInt(p, 10));
+  const year = parts[0];
+  const month = parts.length >= 2 ? parts[1] - 1 : 0;
+  const day = parts.length >= 3 ? parts[2] : 1;
+  return new Date(year, month, day);
+}
+function parseDateToFractionalYear(s) {
+  return dateToFractionalYear(parseDateStringToDate(s));
+}
+var FADE_OPACITY = 0.1;
+function highlightDeps(g, svg, taskId, resolved) {
+  const related = /* @__PURE__ */ new Set([taskId]);
+  const task = resolved.tasks.find((t) => t.task.id === taskId);
+  if (!task) return;
+  for (const rt of resolved.tasks) {
+    for (const dep of rt.task.dependencies) {
+      const depKey = normalizeName(dep.targetName);
+      if (depKey === normalizeName(task.task.label) || normalizeName(
+        `${task.groupPath.join(".")}.${task.task.label}`
+      ).endsWith(depKey)) {
+        related.add(rt.task.id);
+      }
+    }
+  }
+  for (const dep of task.task.dependencies) {
+    const target = resolved.tasks.find(
+      (t) => t.task.label === dep.targetName || `${t.groupPath.join(".")}.${t.task.label}`.endsWith(dep.targetName)
+    );
+    if (target) related.add(target.task.id);
+  }
+  g.selectAll(".gantt-task").each(function() {
+    const el = d3Selection.select(this);
+    const id = el.attr("data-task-id");
+    el.attr("opacity", id && related.has(id) ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-milestone").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+  g.selectAll(".gantt-lane-band, .gantt-lane-accent").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+  g.selectAll(
+    ".gantt-dep-arrow, .gantt-dep-arrowhead"
+  ).each(function() {
+    const el = d3Selection.select(this);
+    const from = el.attr("data-dep-from");
+    const to = el.attr("data-dep-to");
+    const isRelated = from && related.has(from) || to && related.has(to);
+    el.attr("opacity", isRelated ? 0.5 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-marker-group").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+}
+function highlightGroup(g, svg, groupName) {
+  g.selectAll(".gantt-task").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-group") === groupName ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-milestone").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-group") === groupName ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-group") === groupName ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-group-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-group") === groupName ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-group") === groupName ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").each(function() {
+    const el = d3Selection.select(this);
+    el.attr(
+      "opacity",
+      el.attr("data-group") === groupName ? 1 : FADE_OPACITY
+    );
+  });
+  svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", FADE_OPACITY);
+  g.selectAll(".gantt-lane-band, .gantt-lane-accent").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+  g.selectAll(".gantt-marker-group").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+}
+function highlightLane(g, svg, tagKey, laneName) {
+  const tagAttr = `data-tag-${tagKey}`;
+  const laneValue = laneName.toLowerCase();
+  g.selectAll(".gantt-task").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr(tagAttr) === laneValue ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-milestone").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr(tagAttr) === laneValue ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr(tagAttr) === laneValue ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-lane-header").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-lane") === laneName ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-lane-band-group").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-lane") === laneName ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-lane") === laneName ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", FADE_OPACITY);
+  g.selectAll(".gantt-marker-group").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+}
+function highlightTask(g, svg, taskId) {
+  g.selectAll(".gantt-task").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-task-id") === taskId ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(".gantt-milestone").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-task-id") === taskId ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", FADE_OPACITY);
+  g.selectAll(
+    ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+  ).attr("opacity", FADE_OPACITY);
+  g.selectAll(
+    ".gantt-dep-arrow, .gantt-dep-arrowhead"
+  ).attr("opacity", FADE_OPACITY);
+  g.selectAll(".gantt-marker-group").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+}
+function highlightMilestone(g, svg, taskId) {
+  g.selectAll(".gantt-task").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+  g.selectAll(".gantt-milestone").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-task-id") === taskId ? 1 : FADE_OPACITY);
+  });
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-task-id") === taskId ? 1 : FADE_OPACITY);
+  });
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-label").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-header").attr("opacity", FADE_OPACITY);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", FADE_OPACITY);
+  g.selectAll(
+    ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+  ).attr("opacity", FADE_OPACITY);
+  g.selectAll(
+    ".gantt-dep-arrow, .gantt-dep-arrowhead"
+  ).attr("opacity", FADE_OPACITY);
+  g.selectAll(".gantt-marker-group").attr(
+    "opacity",
+    FADE_OPACITY
+  );
+}
+function highlightTaskLabel(svg, lineNumber) {
+  const ln = String(lineNumber);
+  svg.selectAll(".gantt-task-label").each(function() {
+    const el = d3Selection.select(this);
+    el.attr("opacity", el.attr("data-line-number") === ln ? 1 : FADE_OPACITY);
+  });
+}
+function resetTaskLabels(svg) {
+  svg.selectAll(".gantt-task-label").attr("opacity", 1);
+}
+function resetHighlight(g, svg) {
+  if (svg.attr("data-critical-path-active") === "true") {
+    applyCriticalPathHighlight(svg, g);
+    return;
+  }
+  g.selectAll(".gantt-task, .gantt-milestone").attr(
+    "opacity",
+    1
+  );
+  g.selectAll(
+    ".gantt-group-bar, .gantt-group-summary"
+  ).attr("opacity", 1);
+  svg.selectAll(".gantt-group-label").attr("opacity", 1);
+  svg.selectAll(".gantt-group-band-bg, .gantt-group-band-accent").attr("opacity", 1);
+  svg.selectAll(".gantt-task-label").attr("opacity", 1);
+  svg.selectAll(".gantt-lane-header").attr("opacity", 1);
+  svg.selectAll(".gantt-lane-band-bg, .gantt-lane-band-accent").attr("opacity", 1);
+  g.selectAll(
+    ".gantt-lane-band, .gantt-lane-accent, .gantt-lane-band-group"
+  ).attr("opacity", 1);
+  g.selectAll(
+    ".gantt-dep-arrow, .gantt-dep-arrowhead"
+  ).attr("opacity", 0.5);
+  g.selectAll(".gantt-marker-group").attr("opacity", 1);
+  g.selectAll(".gantt-era-group").attr("opacity", 1);
+}
+function buildRowList(resolved, collapsedGroups) {
+  const rows = [];
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const g of resolved.groups) {
+    groupMap.set(g.name, g);
+  }
+  const groupOrder = /* @__PURE__ */ new Map();
+  resolved.groups.forEach((g, i) => groupOrder.set(g.name, i));
+  const sortedTasks = [...resolved.tasks].sort((a, b) => {
+    const maxLen = Math.max(a.groupPath.length, b.groupPath.length);
+    for (let i = 0; i < maxLen; i++) {
+      const ga = a.groupPath[i];
+      const gb = b.groupPath[i];
+      if (ga === gb) continue;
+      if (ga === void 0) return -1;
+      if (gb === void 0) return 1;
+      const oa = groupOrder.get(ga) ?? 0;
+      const ob = groupOrder.get(gb) ?? 0;
+      if (oa !== ob) return oa - ob;
+    }
+    return 0;
+  });
+  const seenGroups = /* @__PURE__ */ new Set();
+  for (const rt of sortedTasks) {
+    const isHidden = rt.groupPath.some((g) => collapsedGroups?.has(g));
+    if (isHidden) {
+      for (const groupName of rt.groupPath) {
+        if (!seenGroups.has(groupName)) {
+          seenGroups.add(groupName);
+          const group = groupMap.get(groupName);
+          if (group) {
+            rows.push({ type: "group", group });
+          }
+        }
+        if (collapsedGroups?.has(groupName)) break;
+      }
+      continue;
+    }
+    for (let i = 0; i < rt.groupPath.length; i++) {
+      const groupName = rt.groupPath[i];
+      if (groupName === void 0) continue;
+      if (!seenGroups.has(groupName)) {
+        seenGroups.add(groupName);
+        const group = groupMap.get(groupName);
+        if (group) {
+          rows.push({ type: "group", group });
+        }
+      }
+    }
+    rows.push({ type: "task", task: rt });
+  }
+  return rows;
+}
+function buildTagLaneRowList(resolved, swimlaneGroup, collapsedLanes) {
+  const tagGroup = resolved.tagGroups.find(
+    (g) => g.name.toLowerCase() === swimlaneGroup.toLowerCase()
+  );
+  if (!tagGroup) return null;
+  const tagKey = tagAttrKey(tagGroup.name);
+  const rows = [];
+  const buckets = /* @__PURE__ */ new Map();
+  const unbucketed = [];
+  for (const rt of resolved.tasks) {
+    let value = rt.effectiveMetadata[tagKey];
+    if (!value && tagGroup.defaultValue) {
+      value = tagGroup.defaultValue;
+    }
+    if (value) {
+      const key = value.toLowerCase();
+      if (!buckets.has(key)) buckets.set(key, []);
+      buckets.get(key).push(rt);
+    } else {
+      unbucketed.push(rt);
+    }
+  }
+  for (const entry of tagGroup.entries) {
+    const entryKey = entry.value.toLowerCase();
+    const tasks = buckets.get(entryKey) ?? [];
+    if (tasks.length === 0) continue;
+    tasks.sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+    const aggregateProgress = durationWeightedProgress(tasks);
+    const laneStartDate = tasks.length > 0 ? new Date(Math.min(...tasks.map((t) => t.startDate.getTime()))) : null;
+    const laneEndDate = tasks.length > 0 ? new Date(Math.max(...tasks.map((t) => t.endDate.getTime()))) : null;
+    const isCollapsed = collapsedLanes?.has(entry.value) ?? false;
+    rows.push({
+      type: "lane-header",
+      laneName: entry.value,
+      laneColor: entry.color,
+      aggregateProgress,
+      tagKey,
+      isCollapsed,
+      laneStartDate,
+      laneEndDate
+    });
+    if (!isCollapsed) {
+      for (const rt of tasks) {
+        rows.push({ type: "task", task: rt });
+      }
+    }
+  }
+  if (unbucketed.length > 0) {
+    unbucketed.sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+    const aggregateProgress = durationWeightedProgress(unbucketed);
+    const noLaneStartDate = unbucketed.length > 0 ? new Date(Math.min(...unbucketed.map((t) => t.startDate.getTime()))) : null;
+    const noLaneEndDate = unbucketed.length > 0 ? new Date(Math.max(...unbucketed.map((t) => t.endDate.getTime()))) : null;
+    const noLaneName = `No ${tagGroup.name}`;
+    const isCollapsed = collapsedLanes?.has(noLaneName) ?? false;
+    rows.push({
+      type: "lane-header",
+      laneName: noLaneName,
+      laneColor: "#999999",
+      aggregateProgress,
+      tagKey,
+      isCollapsed,
+      laneStartDate: noLaneStartDate,
+      laneEndDate: noLaneEndDate
+    });
+    if (!isCollapsed) {
+      for (const rt of unbucketed) {
+        rows.push({ type: "task", task: rt });
+      }
+    }
+  }
+  return rows;
+}
+function durationWeightedProgress(tasks) {
+  let totalDuration = 0;
+  let totalProgress = 0;
+  let hasProgress = false;
+  for (const rt of tasks) {
+    const dur = rt.endDate.getTime() - rt.startDate.getTime();
+    totalDuration += dur;
+    if (rt.task.progress !== null) {
+      totalProgress += rt.task.progress * dur;
+      hasProgress = true;
+    }
+  }
+  return hasProgress && totalDuration > 0 ? totalProgress / totalDuration : null;
+}
+function dateToFractionalYear(d) {
+  const y = d.getFullYear();
+  const startOfYear = new Date(y, 0, 1);
+  const endOfYear = new Date(y + 1, 0, 1);
+  const fraction = (d.getTime() - startOfYear.getTime()) / (endOfYear.getTime() - startOfYear.getTime());
+  return y + fraction;
+}
+function diamondPoints(cx, cy, size) {
+  const half = size / 2;
+  return `${cx},${cy - half} ${cx + half},${cy} ${cx},${cy + half} ${cx - half},${cy}`;
+}
+function formatGanttDate(d) {
+  const base = `${MONTH_ABBR[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()}`;
+  if (d.getHours() === 0 && d.getMinutes() === 0) return base;
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  return `${base} ${hh}:${mm}`;
+}
+function showGanttDateIndicators(g, xScale, startDate, endDate, innerHeight, color, options) {
+  g.selectAll(".gantt-scale-tick").attr("opacity", 0.05);
+  g.selectAll(".gantt-today").attr("opacity", 0.05);
+  const hg = g.append("g").attr("class", "gantt-hover-date").attr("pointer-events", "none");
+  const tickLen = 6;
+  const startPos = xScale(dateToFractionalYear(startDate));
+  const startLabel = formatGanttDate(startDate);
+  if (!options?.skipStartLine) {
+    hg.append("line").attr("class", "gantt-hover-date").attr("x1", startPos).attr("y1", -tickLen).attr("x2", startPos).attr("y2", innerHeight).attr("stroke", color).attr("stroke-width", 1.5).attr("stroke-dasharray", "4 4").attr("opacity", 0.6);
+  }
+  hg.append("text").attr("class", "gantt-hover-date").attr("x", startPos).attr("y", -tickLen - 4).attr("text-anchor", "middle").attr("fill", color).attr("font-size", "10px").attr("font-weight", "600").text(startLabel);
+  hg.append("text").attr("class", "gantt-hover-date").attr("x", startPos).attr("y", innerHeight + tickLen + 12).attr("text-anchor", "middle").attr("fill", color).attr("font-size", "10px").attr("font-weight", "600").text(startLabel);
+  if (endDate && endDate.getTime() !== startDate.getTime()) {
+    const endPos = xScale(dateToFractionalYear(endDate));
+    const endLabel = formatGanttDate(endDate);
+    const minLabelGap = 90;
+    const gap = endPos - startPos;
+    let startLabelX = startPos;
+    let endLabelX = endPos;
+    let startAnchor = "middle";
+    let endAnchor = "middle";
+    if (gap < minLabelGap) {
+      const mid = (startPos + endPos) / 2;
+      startLabelX = mid - minLabelGap / 2;
+      endLabelX = mid + minLabelGap / 2;
+      startAnchor = "middle";
+      endAnchor = "middle";
+    }
+    hg.append("line").attr("class", "gantt-hover-date").attr("x1", endPos).attr("y1", -tickLen).attr("x2", endPos).attr("y2", innerHeight).attr("stroke", color).attr("stroke-width", 1.5).attr("stroke-dasharray", "4 4").attr("opacity", 0.6);
+    hg.selectAll("text.gantt-hover-date").each(
+      function() {
+        const el = d3Selection.select(this);
+        if (el.text() === startLabel) {
+          el.attr("x", startLabelX).attr("text-anchor", startAnchor);
+        }
+      }
+    );
+    hg.append("text").attr("class", "gantt-hover-date").attr("x", endLabelX).attr("y", -tickLen - 4).attr("text-anchor", endAnchor).attr("fill", color).attr("font-size", "10px").attr("font-weight", "600").text(endLabel);
+    hg.append("text").attr("class", "gantt-hover-date").attr("x", endLabelX).attr("y", innerHeight + tickLen + 12).attr("text-anchor", endAnchor).attr("fill", color).attr("font-size", "10px").attr("font-weight", "600").text(endLabel);
+  }
+}
+function hideGanttDateIndicators(g) {
+  g.selectAll(".gantt-hover-date").remove();
+  g.selectAll(".gantt-scale-tick").each(function() {
+    const el = d3Selection.select(this);
+    const isDashed = el.attr("stroke-dasharray");
+    el.attr("opacity", isDashed ? 0.15 : 0.4);
+  });
+  g.selectAll(".gantt-today").attr("opacity", 0.7);
+}
+function resolveTaskColor(rt, activeTagGroup, resolved, seriesColors, palette) {
+  const tagColor = resolveTagColor(
+    rt.effectiveMetadata,
+    resolved.tagGroups,
+    activeTagGroup
+  );
+  if (tagColor && tagColor !== "#999999") return tagColor;
+  if (rt.groupPath.length > 0) {
+    const topGroup = rt.groupPath[0];
+    const groupIdx = resolved.groups.findIndex((g) => g.name === topGroup);
+    if (groupIdx >= 0) {
+      const group = resolved.groups[groupIdx];
+      if (group.color) return group.color;
+      return seriesColors[groupIdx % seriesColors.length];
+    }
+  }
+  return palette.accent || seriesColors[0] || "#4a90d9";
+}
+function renderTimeScaleHorizontal(g, scale, _innerWidth, innerHeight, textColor) {
+  const domain = scale.domain();
+  const domainMin = domain[0];
+  const domainMax = domain[1];
+  const ticks = computeTimeTicks(domainMin, domainMax, scale);
+  if (ticks.length < 2) return;
+  const tickLen = 6;
+  const opacity = 0.4;
+  const guideOpacity = 0.15;
+  for (const tick of ticks) {
+    g.append("line").attr("class", "gantt-scale-tick").attr("x1", tick.pos).attr("y1", 0).attr("x2", tick.pos).attr("y2", innerHeight).attr("stroke", textColor).attr("stroke-width", 1).attr("stroke-dasharray", "4 4").attr("opacity", guideOpacity);
+    g.append("line").attr("class", "gantt-scale-tick").attr("x1", tick.pos).attr("y1", 0).attr("x2", tick.pos).attr("y2", -tickLen).attr("stroke", textColor).attr("stroke-width", 1).attr("opacity", opacity);
+    g.append("text").attr("class", "gantt-scale-tick").attr("x", tick.pos).attr("y", -tickLen - 4).attr("text-anchor", "middle").attr("dominant-baseline", "auto").attr("font-size", "10px").attr("fill", textColor).attr("opacity", opacity).text(tick.label);
+    g.append("line").attr("class", "gantt-scale-tick").attr("x1", tick.pos).attr("y1", innerHeight).attr("x2", tick.pos).attr("y2", innerHeight + tickLen).attr("stroke", textColor).attr("stroke-width", 1).attr("opacity", opacity);
+    g.append("text").attr("class", "gantt-scale-tick").attr("x", tick.pos).attr("y", innerHeight + tickLen + 12).attr("text-anchor", "middle").attr("font-size", "10px").attr("fill", textColor).attr("opacity", opacity).text(tick.label);
+  }
+}
+
+export {
+  renderGantt,
+  buildTagLaneRowList
+};
+//# sourceMappingURL=chunk-G2H74XJZ.js.map