gantt-lib 0.142.2 → 0.143.0

package/dist/index.mjs

@@ -3,7 +3,7 @@
 "use client";
 
 // src/components/GanttChart/GanttChart.tsx
-import { useMemo as useMemo14, useCallback as useCallback10, useRef as useRef13, useState as useState13, useEffect as useEffect12, useImperativeHandle, forwardRef } from "react";
+import { useMemo as useMemo14, useCallback as useCallback11, useRef as useRef14, useState as useState13, useEffect as useEffect12, useImperativeHandle, forwardRef } from "react";
 
 // src/core/scheduling/dateMath.ts
 var DAY_MS = 24 * 60 * 60 * 1e3;
@@ -4610,6 +4610,7 @@ function createTaskPreviewPositionStore() {
 }
 function createActivityPreviewStore() {
   let overridesByTask = /* @__PURE__ */ new Map();
+  let draggedRange;
   const listenersByTaskId = /* @__PURE__ */ new Map();
   function notify(taskIds) {
     for (const taskId of taskIds) {
@@ -4630,6 +4631,16 @@ function createActivityPreviewStore() {
         }
       };
     },
+    getActivityRange(taskId, activityId) {
+      return draggedRange?.taskId === taskId && draggedRange.activityId === activityId ? draggedRange : void 0;
+    },
+    setActivityRange(taskId, activityId, range) {
+      if (draggedRange?.taskId === taskId && draggedRange.activityId === activityId && draggedRange.startDate.getTime() === range.startDate.getTime() && draggedRange.endDate.getTime() === range.endDate.getTime()) return;
+      const changed = /* @__PURE__ */ new Set([taskId]);
+      if (draggedRange) changed.add(draggedRange.taskId);
+      draggedRange = { taskId, activityId, ...range };
+      notify(changed);
+    },
     getTaskOverrides(taskId) {
       return overridesByTask.get(taskId);
     },
@@ -4650,10 +4661,10 @@ function createActivityPreviewStore() {
       notify(changedTaskIds);
     },
     clear() {
-      if (overridesByTask.size === 0) {
-        return;
-      }
+      if (overridesByTask.size === 0 && !draggedRange) return;
       const changedTaskIds = new Set(overridesByTask.keys());
+      if (draggedRange) changedTaskIds.add(draggedRange.taskId);
+      draggedRange = void 0;
       overridesByTask = /* @__PURE__ */ new Map();
       notify(changedTaskIds);
     }
@@ -4999,13 +5010,6 @@ var TaskRow = React2.memo(
     const activityDragStart = useRef2(null);
     const activityConstraintRef = useRef2(null);
     const [activityBlockedBy, setActivityBlockedBy] = useState2(null);
-    const visibleActivitySegments = useMemo2(() => {
-      if (!activityLayout) return [];
-      const window2 = horizontalWindow;
-      if (!window2) return activityLayout.segments;
-      const draggedId = activityDrag?.id;
-      return activityLayout.segments.filter((segment) => segment.id === draggedId || segment.left <= window2.endPx && segment.left + segment.width >= window2.startPx);
-    }, [activityLayout, horizontalWindow, activityDrag?.id]);
     const subscribeActivityOverrides = useCallback2(
       (listener) => activityPreviewStore?.subscribeTask(task.id, listener) ?? (() => {
       }),
@@ -5020,6 +5024,15 @@ var TaskRow = React2.memo(
       getActivityOverridesSnapshot,
       () => void 0
     );
+    const visibleActivitySegments = useMemo2(() => {
+      if (!activityLayout) return [];
+      if (!horizontalWindow) return activityLayout.segments;
+      return activityLayout.segments.filter((segment) => {
+        if (segment.id === activityDrag?.id) return true;
+        const left2 = segment.left + (activityOverrides?.get(segment.id) ?? 0) * dayWidth;
+        return left2 <= horizontalWindow.endPx && left2 + segment.width >= horizontalWindow.startPx;
+      });
+    }, [activityLayout, horizontalWindow, activityDrag?.id, activityOverrides, dayWidth]);
     const subscribeActivityBlock = useCallback2(
       (listener) => activityBlockStore?.subscribeTask(task.id, listener) ?? (() => {
       }),
@@ -5145,6 +5158,11 @@ var TaskRow = React2.memo(
           });
         }
         publishChainPreview(activityDrag.id, activityDrag.mode, clamped);
+        const sourceActivity = task.activities?.find((activity) => activity.id === activityDrag.id);
+        if (sourceActivity) activityPreviewStore?.setActivityRange?.(task.id, activityDrag.id, {
+          startDate: shiftActivityDay(sourceActivity.startDate, activityDrag.mode === "resize-right" ? 0 : clamped),
+          endDate: shiftActivityDay(sourceActivity.endDate, activityDrag.mode === "resize-left" ? 0 : clamped)
+        });
       };
       const onUp = () => {
         activityPreviewStore?.clear();
@@ -5250,6 +5268,53 @@ var TaskRow = React2.memo(
       }
       return { left: segment.left, width: segment.width + activityDrag.dayDelta * dayWidth };
     };
+    const activityLinks = useMemo2(() => {
+      const gaps = [];
+      const elbows = [];
+      if (!showActivityLinks || !renderActivities || !activityLayout) return { gaps, elbows };
+      const activities = task.activities ?? [];
+      const segmentById = new Map(activityLayout.segments.map((segment) => [segment.id, segment]));
+      const visibleIds = new Set(visibleActivitySegments.map((segment) => segment.id));
+      const laneTopY = (lane) => activityTopOffset + lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2;
+      const liveRect = (segment) => {
+        const geometry = liveActivityGeometry(segment);
+        const chainDelta = activityOverrides?.get(segment.id) ?? 0;
+        const left2 = geometry.left + (chainDelta !== 0 ? chainDelta * dayWidth : 0);
+        return { left: left2, right: left2 + geometry.width };
+      };
+      for (let index = 0; index < activities.length - 1; index += 1) {
+        const predecessor = segmentById.get(activities[index].id);
+        const successor = segmentById.get(activities[index + 1].id);
+        if (!predecessor || !successor) continue;
+        if (!visibleIds.has(predecessor.id) || !visibleIds.has(successor.id)) continue;
+        const lag = activities[index + 1].lag ?? 0;
+        const predRect = liveRect(predecessor);
+        const succRect = liveRect(successor);
+        if (predecessor.lane === successor.lane && succRect.left >= predRect.right) {
+          const width2 = succRect.left - predRect.right;
+          if (width2 >= 1) {
+            gaps.push({ key: `${predecessor.id}->${successor.id}`, left: predRect.right, width: width2, lane: predecessor.lane, lag });
+          }
+          continue;
+        }
+        const predecessorLaneTop = laneTopY(predecessor.lane);
+        const successorLaneTop = laneTopY(successor.lane);
+        const sameLane = predecessor.lane === successor.lane;
+        const reverseOrder = !sameLane && successorLaneTop < predecessorLaneTop;
+        const fromY = reverseOrder ? predecessorLaneTop + 6 : predecessorLaneTop + ACTIVITY_LANE_BAR_HEIGHT - 6;
+        const toY = reverseOrder ? successorLaneTop + ACTIVITY_LANE_BAR_HEIGHT - 6 : successorLaneTop + (sameLane ? ACTIVITY_LANE_STEP : 0) + 6;
+        const fromX = predRect.right;
+        const toX = succRect.left;
+        elbows.push({
+          key: `${predecessor.id}->${successor.id}`,
+          d: calculateDependencyPath({ x: fromX, y: fromY }, { x: toX, y: toY }, false),
+          lagX: toX - 14,
+          lagY: reverseOrder ? fromY - 4 : fromY + 12,
+          lag
+        });
+      }
+      return { gaps, elbows };
+    }, [showActivityLinks, renderActivities, activityLayout, visibleActivitySegments, activityTopOffset, activityOverrides, activityDrag, dayWidth, task.activities]);
     const activityTipData = useMemo2(() => {
       if (!activityTipId || !task.activities) return null;
       const activity = task.activities.find((item) => item.id === activityTipId);
@@ -5321,72 +5386,121 @@ var TaskRow = React2.memo(
                 }
               }
             ),
-            renderActivities && activityLayout && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-activityLanes", children: visibleActivitySegments.map((segment) => {
-              const live = liveActivityGeometry(segment);
-              const chainDelta = activityOverrides?.get(segment.id) ?? 0;
-              const activityProgress = segment.progress === void 0 ? 0 : Math.min(100, Math.max(0, Math.round(segment.progress)));
-              const liveLeft = live.left + (chainDelta !== 0 ? chainDelta * dayWidth : 0);
-              const isDraggingActivity = activityDrag?.id === segment.id;
-              const isBlockingActivity = blockedActivityIds?.has(segment.id) ?? false;
-              const isAtLimit = isDraggingActivity && activityBlockedBy !== null;
-              const isActiveActivity = activationVisualEnabled && activeActivityKey === activityOwnerKey(task.id, segment.id);
-              const isSameWorkType = activeWork !== null && (segment.id === activeWork.id || activeWork.name !== null && segment.name === activeWork.name);
-              const isDimmed = dimOthers && activeWork !== null && !isSameWorkType;
-              const isChainHighlighted = highlightChain && activeWork !== null && isSameWorkType;
-              return /* @__PURE__ */ jsxs2(
-                "div",
-                {
-                  "data-activity-id": segment.id,
-                  className: `gantt-tr-activityBar${isDraggingActivity ? " gantt-tr-activityBar-dragging" : ""}${isBlockingActivity ? " gantt-tr-activityBar-blocking" : ""}${isAtLimit ? " gantt-tr-activityBar-atLimit" : ""}${isActiveActivity ? " gantt-tr-activityBar-active" : ""}${isDimmed ? " gantt-tr-activityBar-dimmed" : ""}${isChainHighlighted ? " gantt-tr-activityBar-chain" : ""}${activityDragEnabled ? "" : " gantt-tr-activityBar-locked"}`,
-                  style: {
-                    left: `${liveLeft}px`,
-                    width: `${live.width}px`,
-                    top: `${activityTopOffset + segment.lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2}px`,
-                    height: `${ACTIVITY_LANE_BAR_HEIGHT}px`,
-                    backgroundColor: segment.color || "var(--gantt-task-bar-default-color)"
-                  },
-                  onMouseDown: (event) => {
-                    if (!activityDragEnabled) return;
-                    const activationKey = activityOwnerKey(task.id, segment.id);
-                    const isActive = activityActivationStore?.getActiveKey() === activationKey;
-                    if (activationVisualEnabled && !isActive) {
-                      activityActivationStore?.setActiveKey(activationKey);
+            renderActivities && activityLayout && /* @__PURE__ */ jsxs2("div", { className: "gantt-tr-activityLanes", children: [
+              activityLinks.elbows.length > 0 && /* @__PURE__ */ jsxs2("svg", { className: "gantt-tr-activityLinksSvg", width: "100%", height: "100%", "aria-hidden": "true", children: [
+                /* @__PURE__ */ jsx2("defs", { children: /* @__PURE__ */ jsx2("marker", { id: "arrowhead", markerWidth: "8", markerHeight: "6", markerUnits: "userSpaceOnUse", refX: "7", refY: "3", orient: "auto", children: /* @__PURE__ */ jsx2("polygon", { points: "0 0, 8 3, 0 6", fill: "var(--gantt-dependency-line-color, #666666)" }) }) }),
+                activityLinks.elbows.map((link) => /* @__PURE__ */ jsxs2("g", { children: [
+                  /* @__PURE__ */ jsx2("path", { className: "gantt-dependency-path", d: link.d, markerEnd: "url(#arrowhead)" }),
+                  showActivityLag && link.lag !== 0 && /* @__PURE__ */ jsx2(
+                    "text",
+                    {
+                      className: "gantt-dependency-lag-label",
+                      x: link.lagX,
+                      y: link.lagY,
+                      textAnchor: "middle",
+                      fontSize: "10",
+                      fill: "var(--gantt-dependency-line-color, #666666)",
+                      children: link.lag > 0 ? `+${link.lag}` : `${link.lag}`
                     }
-                    if (activityClickToDrag && !isActive) return;
-                    const target = event.target;
-                    const mode = target.closest(".gantt-tr-resizeHandleLeft") ? "resize-left" : target.closest(".gantt-tr-resizeHandleRight") ? "resize-right" : "move";
-                    handleActivityPointerDown(segment, mode)(event);
-                  },
-                  onMouseEnter: (event) => {
-                    if (activityDrag || activityDragOwner?.get()) return;
-                    setActivityTipPosition(anchorActivityTip(event.currentTarget.getBoundingClientRect()));
-                    setActivityTipId(segment.id);
+                  )
+                ] }, link.key))
+              ] }),
+              visibleActivitySegments.map((segment) => {
+                const live = liveActivityGeometry(segment);
+                const chainDelta = activityOverrides?.get(segment.id) ?? 0;
+                const activityProgress = segment.progress === void 0 ? 0 : Math.min(100, Math.max(0, Math.round(segment.progress)));
+                const liveLeft = live.left + (chainDelta !== 0 ? chainDelta * dayWidth : 0);
+                const isDraggingActivity = activityDrag?.id === segment.id;
+                const isBlockingActivity = blockedActivityIds?.has(segment.id) ?? false;
+                const isAtLimit = isDraggingActivity && activityBlockedBy !== null;
+                const isActiveActivity = activationVisualEnabled && activeActivityKey === activityOwnerKey(task.id, segment.id);
+                const isSameWorkType = activeWork !== null && (segment.id === activeWork.id || activeWork.name !== null && segment.name === activeWork.name);
+                const isDimmed = dimOthers && activeWork !== null && !isSameWorkType;
+                const isChainHighlighted = highlightChain && activeWork !== null && isSameWorkType;
+                return /* @__PURE__ */ jsxs2(
+                  "div",
+                  {
+                    "data-activity-id": segment.id,
+                    className: `gantt-tr-activityBar${isDraggingActivity ? " gantt-tr-activityBar-dragging" : ""}${isBlockingActivity ? " gantt-tr-activityBar-blocking" : ""}${isAtLimit ? " gantt-tr-activityBar-atLimit" : ""}${isActiveActivity ? " gantt-tr-activityBar-active" : ""}${isDimmed ? " gantt-tr-activityBar-dimmed" : ""}${isChainHighlighted ? " gantt-tr-activityBar-chain" : ""}${activityDragEnabled ? "" : " gantt-tr-activityBar-locked"}`,
+                    style: {
+                      left: `${liveLeft}px`,
+                      width: `${live.width}px`,
+                      top: `${activityTopOffset + segment.lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2}px`,
+                      height: `${ACTIVITY_LANE_BAR_HEIGHT}px`,
+                      backgroundColor: segment.color || "var(--gantt-task-bar-default-color)"
+                    },
+                    onMouseDown: (event) => {
+                      if (!activityDragEnabled) return;
+                      const activationKey = activityOwnerKey(task.id, segment.id);
+                      const isActive = activityActivationStore?.getActiveKey() === activationKey;
+                      if (activationVisualEnabled && !isActive) {
+                        activityActivationStore?.setActiveKey(activationKey);
+                      }
+                      if (activityClickToDrag && !isActive) return;
+                      const target = event.target;
+                      const mode = target.closest(".gantt-tr-resizeHandleLeft") ? "resize-left" : target.closest(".gantt-tr-resizeHandleRight") ? "resize-right" : "move";
+                      handleActivityPointerDown(segment, mode)(event);
+                    },
+                    onMouseEnter: (event) => {
+                      if (activityDrag || activityDragOwner?.get()) return;
+                      setActivityTipPosition(anchorActivityTip(event.currentTarget.getBoundingClientRect()));
+                      setActivityTipId(segment.id);
+                    },
+                    onMouseLeave: () => {
+                      if (!activityDrag) {
+                        setActivityTipId((current) => current === segment.id ? null : current);
+                        activityTipAnchor.current = null;
+                        setActivityTipPosition(null);
+                      }
+                    },
+                    children: [
+                      activityProgress > 0 && /* @__PURE__ */ jsx2(
+                        "span",
+                        {
+                          className: "gantt-tr-activityProgress",
+                          style: { width: `${activityProgress}%` }
+                        }
+                      ),
+                      /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityName", style: { color: activityTextColor(segment.color) }, children: segment.name }),
+                      activityDragEnabled && /* @__PURE__ */ jsxs2(Fragment, { children: [
+                        /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
+                        /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
+                      ] })
+                    ]
                   },
-                  onMouseLeave: () => {
-                    if (!activityDrag) {
-                      setActivityTipId((current) => current === segment.id ? null : current);
-                      activityTipAnchor.current = null;
-                      setActivityTipPosition(null);
+                  segment.id
+                );
+              }),
+              activityLinks.gaps.map((gap) => /* @__PURE__ */ jsxs2(React2.Fragment, { children: [
+                /* @__PURE__ */ jsx2(
+                  "span",
+                  {
+                    className: "gantt-tr-activityLink",
+                    "aria-hidden": "true",
+                    style: {
+                      left: `${gap.left}px`,
+                      width: `${gap.width}px`,
+                      top: `${activityTopOffset + gap.lane * ACTIVITY_LANE_STEP + ACTIVITY_LANE_STEP / 2}px`
                     }
-                  },
-                  children: [
-                    activityProgress > 0 && /* @__PURE__ */ jsx2(
-                      "span",
-                      {
-                        className: "gantt-tr-activityProgress",
-                        style: { width: `${activityProgress}%` }
-                      }
-                    ),
-                    /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityName", style: { color: activityTextColor(segment.color) }, children: segment.name }),
-                    activityDragEnabled && /* @__PURE__ */ jsxs2(Fragment, { children: [
-                      /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
-                      /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
-                    ] })
-                  ]
-                },
-                segment.id
-              );
-            }) }),
+                  }
+                ),
+                showActivityLag && gap.lag > 0 && /* @__PURE__ */ jsxs2(
+                  "span",
+                  {
+                    className: "gantt-tr-activityLag",
+                    title: `\u0417\u0430\u0437\u043E\u0440 ${gap.lag} \u0434`,
+                    style: {
+                      left: `${gap.left + gap.width - 14}px`,
+                      top: `${activityTopOffset + gap.lane * ACTIVITY_LANE_STEP + ACTIVITY_LANE_STEP / 2}px`
+                    },
+                    children: [
+                      "+",
+                      gap.lag
+                    ]
+                  }
+                )
+              ] }, gap.key))
+            ] }),
             !renderActivities && /* @__PURE__ */ jsxs2(
               "div",
               {
@@ -5929,7 +6043,7 @@ var DragGuideLines = ({
 var DragGuideLines_default = DragGuideLines;
 
 // src/components/DependencyLines/DependencyLines.tsx
-import React6, { useId, useMemo as useMemo6, useState as useState3 } from "react";
+import React6, { useCallback as useCallback3, useId, useMemo as useMemo6, useState as useState3 } from "react";
 import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function isTaskHidden(taskId, collapsedParentIds, taskMap) {
   const task = taskMap.get(taskId);
@@ -5959,6 +6073,74 @@ function areBothHiddenInSameParent(predecessorId, successorId, collapsedParentId
   return predVisibleAncestor.id === succVisibleAncestor.id;
 }
 var EMPTY_COLLAPSED_PARENT_IDS = /* @__PURE__ */ new Set();
+var DependencyLineView = React6.memo(function DependencyLineView2({
+  line,
+  hovered,
+  selected,
+  showLag,
+  markerPrefix,
+  onLineHover,
+  onLineLeave,
+  onDependencyClick
+}) {
+  const { id, predecessorId, successorId, linkType, path, hasCycle, lag, toX, fromY, reverseOrder, isVirtual, isCoupling } = line;
+  const interactive = !isCoupling && onDependencyClick !== void 0;
+  let pathClassName = "gantt-dependency-path";
+  if (selected) pathClassName += " gantt-dependency-selected";
+  else if (hasCycle) pathClassName += " gantt-dependency-cycle";
+  else if (line.isCritical) pathClassName += " gantt-dependency-critical";
+  if (isVirtual && !selected) pathClassName += " gantt-dependency-virtual";
+  let markerEnd;
+  if (hovered) markerEnd = `url(#${markerPrefix}-arrowhead-hover)`;
+  else if (selected) markerEnd = `url(#${markerPrefix}-arrowhead-selected)`;
+  else if (hasCycle) markerEnd = `url(#${markerPrefix}-arrowhead-cycle)`;
+  else if (line.isCritical) markerEnd = `url(#${markerPrefix}-arrowhead-critical)`;
+  else markerEnd = `url(#${markerPrefix}-arrowhead)`;
+  const lagColor = selected ? "#ef4444" : hasCycle ? "var(--gantt-dependency-cycle-color, #ef4444)" : line.isCritical ? "var(--gantt-critical-path-color, #dc2626)" : "var(--gantt-dependency-line-color, #666666)";
+  return /* @__PURE__ */ jsxs5(React6.Fragment, { children: [
+    /* @__PURE__ */ jsx7(
+      "g",
+      {
+        className: `gantt-dependency-line${interactive ? "" : " gantt-dependency-line-static"}${hovered && interactive ? " gantt-dependency-line-hovered" : ""}`,
+        onPointerEnter: interactive ? () => onLineHover(id) : void 0,
+        onPointerLeave: interactive ? () => onLineLeave(id) : void 0,
+        onClick: interactive ? (event) => {
+          event.stopPropagation();
+          onDependencyClick?.({
+            predecessorId,
+            successorId,
+            linkType,
+            x: toX,
+            y: reverseOrder ? fromY - 4 : fromY + 12
+          });
+        } : void 0,
+        role: interactive ? "button" : void 0,
+        "aria-label": interactive ? `\u0421\u0432\u044F\u0437\u044C ${linkType}` : void 0,
+        children: isCoupling ? /* @__PURE__ */ jsx7("line", { x1: toX - 4.5, y1: fromY, x2: toX + 4.5, y2: fromY, className: `${pathClassName} gantt-dependency-coupling` }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+          interactive && /* @__PURE__ */ jsx7("path", { d: path, className: "gantt-dependency-hit-area" }),
+          /* @__PURE__ */ jsx7("path", { d: path, className: pathClassName, markerEnd })
+        ] })
+      }
+    ),
+    showLag && lag !== 0 && /* @__PURE__ */ jsx7(
+      "text",
+      {
+        className: "gantt-dependency-lag-label",
+        x: lag < 0 ? toX + 14 : toX - 14,
+        y: reverseOrder ? fromY - 4 : fromY + 12,
+        textAnchor: "middle",
+        fontSize: "10",
+        fill: lagColor,
+        children: lag > 0 ? `+${lag}` : `${lag}`
+      }
+    )
+  ] });
+}, (prev, next) => (
+  // Сравнение по значению, а не по ссылке линии: пересчёт геометрии на каждом
+  // бакете вертикальной прокрутки создаёт новые объекты линий с той же
+  // геометрией — пере-рендерить их нельзя, иначе пан дёргается.
+  prev.line.id === next.line.id && prev.line.predecessorId === next.line.predecessorId && prev.line.successorId === next.line.successorId && prev.line.linkType === next.line.linkType && prev.line.path === next.line.path && prev.line.hasCycle === next.line.hasCycle && prev.line.lag === next.line.lag && prev.line.toX === next.line.toX && prev.line.fromY === next.line.fromY && prev.line.reverseOrder === next.line.reverseOrder && prev.line.isVirtual === next.line.isVirtual && prev.line.isCritical === next.line.isCritical && prev.line.isCoupling === next.line.isCoupling && prev.hovered === next.hovered && prev.selected === next.selected && prev.showLag === next.showLag && prev.markerPrefix === next.markerPrefix && prev.onLineHover === next.onLineHover && prev.onLineLeave === next.onLineLeave && prev.onDependencyClick === next.onDependencyClick
+));
 var DependencyLines = React6.memo(({
   tasks,
   allTasks,
@@ -5974,6 +6156,7 @@ var DependencyLines = React6.memo(({
   dragOverrides,
   selectedDep,
   criticalTaskIds,
+  cycleTaskIds,
   showLag = true,
   activityEndpoints = false,
   businessDays = true,
@@ -5984,13 +6167,16 @@ var DependencyLines = React6.memo(({
   const markerPrefix = `gantt-dependency-${useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
   const markerId = (kind) => `${markerPrefix}-${kind}`;
   const [hoveredLineId, setHoveredLineId] = useState3(null);
+  const handleLineHover = useCallback3((id) => setHoveredLineId(id), []);
+  const handleLineLeave = useCallback3((id) => setHoveredLineId((current) => current === id ? null : current), []);
   const tasksForPositions = allTasks ?? tasks;
+  const geometryTasks = activityEndpoints ? tasksForPositions : tasks;
   const { taskPositions, taskIndices, hiddenTaskIds } = useMemo6(() => {
     const positions = /* @__PURE__ */ new Map();
     const indices = /* @__PURE__ */ new Map();
     const hidden = /* @__PURE__ */ new Set();
     const taskMap = new Map(tasksForPositions.map((t) => [t.id, t]));
-    tasks.forEach((task, index) => {
+    geometryTasks.forEach((task, index) => {
       const override = dragOverrides?.get(task.id);
       const computed = resolveTaskHorizontalGeometry(task, monthStart, dayWidth, override);
       const rowIndex = rowIndexByTaskId?.get(task.id) ?? index;
@@ -6046,18 +6232,19 @@ var DependencyLines = React6.memo(({
       }
     }
     return { taskPositions: positions, taskIndices: indices, hiddenTaskIds: hidden };
-  }, [tasks, tasksForPositions, allTasks, collapsedParentIds, monthStart, dayWidth, rowHeight, rowTops, rowHeights, dragOverrides, rowIndexByTaskId]);
+  }, [geometryTasks, tasksForPositions, allTasks, collapsedParentIds, monthStart, dayWidth, rowHeight, rowTops, rowHeights, dragOverrides, rowIndexByTaskId]);
   const tasksForCycleDetection = allTasks ?? tasks;
   const cycleInfo = useMemo6(() => {
+    if (cycleTaskIds) return cycleTaskIds;
     const result = detectCycles(tasksForCycleDetection);
-    const cycleTaskIds = new Set(result.cyclePath || []);
-    return cycleTaskIds;
-  }, [tasksForCycleDetection]);
+    const detectedCycleIds = new Set(result.cyclePath || []);
+    return detectedCycleIds;
+  }, [tasksForCycleDetection, cycleTaskIds]);
   const lines = useMemo6(() => {
-    const tasksForEdges = allTasks ?? tasks;
+    const tasksForEdges = allTasks ?? geometryTasks;
     const taskMap = new Map(tasksForEdges.map((task) => [task.id, task]));
     const positionedTaskIds = Array.from(taskPositions.keys());
-    const renderedTaskIdSet = new Set(tasks.map((t) => t.id));
+    const renderedTaskIdSet = new Set(geometryTasks.map((t) => t.id));
     const lines2 = [];
     for (const successorId of positionedTaskIds) {
       const successorTaskForEdges = taskMap.get(successorId);
@@ -6152,16 +6339,20 @@ var DependencyLines = React6.memo(({
       }
     }
     return lines2;
-  }, [tasks, allTasks, taskPositions, taskIndices, cycleInfo, collapsedParentIds, criticalTaskIds, activityEndpoints]);
+  }, [geometryTasks, allTasks, taskPositions, taskIndices, cycleInfo, collapsedParentIds, criticalTaskIds, activityEndpoints]);
   const visibleLines = useMemo6(() => {
-    if (!horizontalWindow) return lines;
-    return lines.filter((line) => Math.max(line.fromX, line.toX) >= horizontalWindow.startPx && Math.min(line.fromX, line.toX) <= horizontalWindow.endPx);
-  }, [lines, horizontalWindow?.startPx, horizontalWindow?.endPx]);
+    const renderedIds = activityEndpoints ? new Set(tasks.map((task) => task.id)) : void 0;
+    return lines.filter((line) => {
+      if (renderedIds && !renderedIds.has(line.predecessorId) && !renderedIds.has(line.successorId)) return false;
+      return !horizontalWindow || Math.max(line.fromX, line.toX) >= horizontalWindow.startPx && Math.min(line.fromX, line.toX) <= horizontalWindow.endPx;
+    });
+  }, [lines, activityEndpoints, tasks, horizontalWindow?.startPx, horizontalWindow?.endPx]);
   const svgHeight = totalHeight ?? tasks.length * rowHeight;
+  const interactive = onDependencyClick !== void 0;
   return /* @__PURE__ */ jsxs5(
     "svg",
     {
-      className: "gantt-dependencies-svg",
+      className: `gantt-dependencies-svg${interactive ? "" : " gantt-dependencies-svg-static"}`,
       "data-testid": "dependency-lines-svg",
       width: gridWidth,
       height: svgHeight,
@@ -6264,63 +6455,22 @@ var DependencyLines = React6.memo(({
             }
           )
         ] }),
-        visibleLines.map(({ id, predecessorId, successorId, linkType, path, hasCycle, lag, fromX, toX, fromY, reverseOrder, isVirtual, isCritical, isCoupling }) => {
-          const isHovered = hoveredLineId === id;
-          const isSelected = selectedDep != null && id === `${selectedDep.predecessorId}-${selectedDep.successorId}-${selectedDep.linkType}`;
-          let pathClassName = "gantt-dependency-path";
-          if (isSelected) pathClassName += " gantt-dependency-selected";
-          else if (hasCycle) pathClassName += " gantt-dependency-cycle";
-          else if (isCritical) pathClassName += " gantt-dependency-critical";
-          if (isVirtual && !isSelected) pathClassName += " gantt-dependency-virtual";
-          let markerEnd;
-          if (isHovered) markerEnd = `url(#${markerId("arrowhead-hover")})`;
-          else if (isSelected) markerEnd = `url(#${markerId("arrowhead-selected")})`;
-          else if (hasCycle) markerEnd = `url(#${markerId("arrowhead-cycle")})`;
-          else if (isCritical) markerEnd = `url(#${markerId("arrowhead-critical")})`;
-          else markerEnd = `url(#${markerId("arrowhead")})`;
-          const lagColor = isSelected ? "#ef4444" : hasCycle ? "var(--gantt-dependency-cycle-color, #ef4444)" : isCritical ? "var(--gantt-critical-path-color, #dc2626)" : "var(--gantt-dependency-line-color, #666666)";
-          return /* @__PURE__ */ jsxs5(React6.Fragment, { children: [
-            /* @__PURE__ */ jsx7(
-              "g",
-              {
-                className: `gantt-dependency-line${isHovered ? " gantt-dependency-line-hovered" : ""}`,
-                onPointerEnter: () => setHoveredLineId(id),
-                onPointerLeave: () => setHoveredLineId((current) => current === id ? null : current),
-                onClick: (event) => {
-                  event.stopPropagation();
-                  onDependencyClick?.({
-                    predecessorId,
-                    successorId,
-                    linkType,
-                    x: toX,
-                    y: reverseOrder ? fromY - 4 : fromY + 12
-                  });
-                },
-                role: "button",
-                "aria-label": `\u0421\u0432\u044F\u0437\u044C ${linkType}`,
-                children: isCoupling ? /* @__PURE__ */ jsxs5(Fragment3, { children: [
-                  /* @__PURE__ */ jsx7("title", { children: "\u041F\u043E\u0441\u043B\u0435 \u043E\u043A\u043E\u043D\u0447\u0430\u043D\u0438\u044F \xB7 \u0431\u0435\u0437 \u043B\u0430\u0433\u0430" }),
-                  /* @__PURE__ */ jsx7("circle", { cx: toX, cy: fromY, r: 12, className: "gantt-dependency-coupling-hit-area" }),
-                  /* @__PURE__ */ jsx7("circle", { cx: toX, cy: fromY, r: 4, className: `${pathClassName} gantt-dependency-coupling` })
-                ] }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
-                  /* @__PURE__ */ jsx7("path", { d: path, className: "gantt-dependency-hit-area" }),
-                  /* @__PURE__ */ jsx7("path", { d: path, className: pathClassName, markerEnd })
-                ] })
-              }
-            ),
-            showLag && lag !== 0 && /* @__PURE__ */ jsx7(
-              "text",
-              {
-                className: "gantt-dependency-lag-label",
-                x: lag < 0 ? toX + 14 : toX - 14,
-                y: reverseOrder ? fromY - 4 : fromY + 12,
-                textAnchor: "middle",
-                fontSize: "10",
-                fill: lagColor,
-                children: lag > 0 ? `+${lag}` : `${lag}`
-              }
-            )
-          ] }, id);
+        visibleLines.map((line) => {
+          const isSelected = selectedDep != null && line.id === `${selectedDep.predecessorId}-${selectedDep.successorId}-${selectedDep.linkType}`;
+          return /* @__PURE__ */ jsx7(
+            DependencyLineView,
+            {
+              line,
+              hovered: hoveredLineId === line.id,
+              selected: isSelected,
+              showLag,
+              markerPrefix,
+              onLineHover: handleLineHover,
+              onLineLeave: handleLineLeave,
+              onDependencyClick
+            },
+            line.id
+          );
         })
       ]
     }
@@ -6330,9 +6480,17 @@ DependencyLines.displayName = "DependencyLines";
 var DependencyLines_default = DependencyLines;
 
 // src/components/DependencyLines/ActivityDependencyLines.tsx
-import { useEffect as useEffect3, useMemo as useMemo7, useReducer } from "react";
+import { useEffect as useEffect3, useMemo as useMemo7, useReducer, useRef as useRef3 } from "react";
 import { jsx as jsx8 } from "react/jsx-runtime";
 var activityKey = (taskId, activityId) => JSON.stringify([taskId, activityId]);
+var sameDependencies = (left, right) => {
+  if (left === right) return true;
+  if (!left || !right || left.length !== right.length) return false;
+  return left.every((dep, index) => {
+    const other = right[index];
+    return dep.taskId === other.taskId && dep.type === other.type && dep.lag === other.lag && dep.hidden === other.hidden;
+  });
+};
 function ActivityDependencyLines(props) {
   const { tasks, dependencies, monthStart, dayWidth, previewStore } = props;
   const [previewVersion, refresh] = useReducer((value) => value + 1, 0);
@@ -6340,15 +6498,29 @@ function ActivityDependencyLines(props) {
     const cleanups = tasks.filter((task) => task.activities?.length).map((task) => previewStore?.subscribeTask(task.id, refresh));
     return () => cleanups.forEach((cleanup) => cleanup?.());
   }, [tasks, previewStore]);
+  const cycleTaskIds = useMemo7(() => {
+    const incoming = /* @__PURE__ */ new Map();
+    for (const edge of dependencies) {
+      const id = activityKey(edge.successorTaskId, edge.successorActivityId);
+      const values = incoming.get(id) ?? [];
+      values.push({ taskId: activityKey(edge.predecessorTaskId, edge.predecessorActivityId), type: edge.type, lag: edge.lag ?? 0 });
+      incoming.set(id, values);
+    }
+    const nodes = tasks.flatMap((task) => (task.activities ?? []).map((activity) => ({ id: activityKey(task.id, activity.id), name: activity.name, startDate: activity.startDate, endDate: activity.endDate, dependencies: incoming.get(activityKey(task.id, activity.id)) })));
+    return new Set(detectCycles(nodes).cyclePath ?? []);
+  }, [tasks, dependencies]);
+  const layoutCacheRef = useRef3(/* @__PURE__ */ new Map());
   const layout = useMemo7(() => {
-    const flattened = [], rendered = [], tops = [], heights = [];
+    const flattened = [], tops = [], heights = [];
+    const nodesByTaskId = /* @__PURE__ */ new Map();
     const indices = /* @__PURE__ */ new Map();
     const neededRows = /* @__PURE__ */ new Set();
     const incoming = /* @__PURE__ */ new Map();
     const selected = props.highlight ? new Set(props.highlight.activities.map((activity) => activityKey(activity.taskId, activity.activityId))) : void 0;
     const highlightMode = props.highlight?.mode ?? "chain";
     for (const edge of dependencies) {
-      if (!props.renderedTaskIds.has(edge.predecessorTaskId) && !props.renderedTaskIds.has(edge.successorTaskId)) continue;
+      const isCrossRow = edge.predecessorTaskId !== edge.successorTaskId;
+      if (isCrossRow && !props.highlight) continue;
       if (selected) {
         const fromSelected = selected.has(activityKey(edge.predecessorTaskId, edge.predecessorActivityId));
         const toSelected = selected.has(activityKey(edge.successorTaskId, edge.successorActivityId));
@@ -6361,33 +6533,75 @@ function ActivityDependencyLines(props) {
       neededRows.add(edge.successorTaskId);
       const id = activityKey(edge.successorTaskId, edge.successorActivityId);
       const values = incoming.get(id) ?? [];
-      values.push({ taskId: activityKey(edge.predecessorTaskId, edge.predecessorActivityId), type: edge.type, lag: edge.lag });
+      values.push({ taskId: activityKey(edge.predecessorTaskId, edge.predecessorActivityId), type: edge.type, lag: edge.lag ?? 0 });
       incoming.set(id, values);
     }
+    const monthStartMs = monthStart.getTime();
+    const cache = layoutCacheRef.current;
     for (const task of tasks) {
       if (!neededRows.has(task.id)) continue;
       const row = props.rowIndexByTaskId.get(task.id);
       if (row === void 0 || !task.activities?.length) continue;
       const height = props.rowHeights[row] ?? props.rowHeight;
       if (height < props.rowHeight) continue;
-      const packed = computeActivityLanes(task.activities, monthStart, dayWidth);
-      const offset = Math.max(0, (height - packed.laneCount * ACTIVITY_LANE_STEP) / 2);
-      const segments2 = new Map(packed.segments.map((segment) => [segment.id, segment]));
-      for (const activity of task.activities) {
-        const segment = segments2.get(activity.id);
-        const id = activityKey(task.id, activity.id), index = flattened.length;
-        const delta = previewStore?.getTaskOverrides(task.id)?.get(activity.id) ?? 0;
-        const node = { id, name: activity.name, startDate: shiftActivityDate(activity.startDate, delta), endDate: shiftActivityDate(activity.endDate, delta), dependencies: incoming.get(id) };
+      const activities = task.activities;
+      const overrides = previewStore?.getTaskOverrides(task.id);
+      let range;
+      for (const activity of activities) {
+        const current = previewStore?.getActivityRange?.(task.id, activity.id);
+        if (current) {
+          range = current;
+          break;
+        }
+      }
+      let entry = cache.get(task.id);
+      const reusable = entry && entry.activities === activities && entry.monthStartMs === monthStartMs && entry.dayWidth === dayWidth && entry.overrides === overrides && entry.range === range && entry.nodes.length === activities.length && entry.nodes.every((node, index) => node.name === activities[index].name && node.startDate === activities[index].startDate && node.endDate === activities[index].endDate && sameDependencies(node.dependencies, incoming.get(node.id)));
+      if (!entry || !reusable) {
+        const liveActivities = activities.map((activity) => {
+          const activityRange = previewStore?.getActivityRange?.(task.id, activity.id);
+          if (activityRange) return { ...activity, startDate: activityRange.startDate, endDate: activityRange.endDate };
+          const delta = overrides?.get(activity.id) ?? 0;
+          if (delta === 0) return activity;
+          return { ...activity, startDate: shiftActivityDate(activity.startDate, delta), endDate: shiftActivityDate(activity.endDate, delta) };
+        });
+        const packed = computeActivityLanes(liveActivities, monthStart, dayWidth);
+        const lanes = new Map(packed.segments.map((segment) => [segment.id, segment.lane]));
+        const rawIds = liveActivities.map((activity) => activity.id);
+        const nodes = liveActivities.map((activity) => ({
+          id: activityKey(task.id, activity.id),
+          name: activity.name,
+          startDate: activity.startDate,
+          endDate: activity.endDate,
+          dependencies: incoming.get(activityKey(task.id, activity.id))
+        }));
+        entry = { activities, monthStartMs, dayWidth, overrides, range, laneCount: packed.laneCount, lanes, rawIds, nodes };
+        cache.set(task.id, entry);
+      }
+      const offset = Math.max(0, (height - entry.laneCount * ACTIVITY_LANE_STEP) / 2);
+      nodesByTaskId.set(task.id, entry.nodes);
+      entry.nodes.forEach((node, nodeIndex) => {
+        const lane = entry.lanes.get(entry.rawIds[nodeIndex]) ?? 0;
+        const index = flattened.length;
         flattened.push(node);
-        if (props.renderedTaskIds.has(task.id)) rendered.push(node);
-        indices.set(id, index);
-        tops.push((props.rowTops[row] ?? row * props.rowHeight) + offset + segment.lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2);
+        indices.set(node.id, index);
+        tops.push((props.rowTops[row] ?? row * props.rowHeight) + offset + lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2);
         heights.push(ACTIVITY_LANE_BAR_HEIGHT);
-      }
+      });
+    }
+    for (const taskId of cache.keys()) {
+      if (!nodesByTaskId.has(taskId)) cache.delete(taskId);
     }
-    return { flattened, rendered, indices, tops, heights };
-  }, [tasks, dependencies, props.highlight, monthStart, dayWidth, props.rowIndexByTaskId, props.rowTops, props.rowHeights, props.rowHeight, props.renderedTaskIds, previewStore, previewVersion]);
-  return /* @__PURE__ */ jsx8(DependencyLines, { tasks: layout.rendered, allTasks: layout.flattened, monthStart, dayWidth, rowHeight: ACTIVITY_LANE_BAR_HEIGHT, gridWidth: props.gridWidth, totalHeight: props.totalHeight, rowIndexByTaskId: layout.indices, rowTops: layout.tops, rowHeights: layout.heights, horizontalWindow: props.horizontalWindow, showLag: props.showLag, activityEndpoints: true });
+    return { flattened, nodesByTaskId, indices, tops, heights };
+  }, [tasks, dependencies, props.highlight, monthStart, dayWidth, props.rowIndexByTaskId, props.rowTops, props.rowHeights, props.rowHeight, previewStore, previewVersion]);
+  const rendered = useMemo7(() => {
+    const nodes = [];
+    for (const taskId of props.renderedTaskIds) {
+      const rowNodes = layout.nodesByTaskId.get(taskId);
+      if (rowNodes) nodes.push(...rowNodes);
+    }
+    return nodes;
+  }, [layout, props.renderedTaskIds]);
+  return /* @__PURE__ */ jsx8(DependencyLines, { tasks: rendered, allTasks: layout.flattened, monthStart, dayWidth, rowHeight: ACTIVITY_LANE_BAR_HEIGHT, gridWidth: props.gridWidth, totalHeight: props.totalHeight, rowIndexByTaskId: layout.indices, rowTops: layout.tops, rowHeights: layout.heights, horizontalWindow: props.horizontalWindow, showLag: props.showLag, cycleTaskIds, activityEndpoints: true });
 }
 
 // src/components/DependencyCreationOverlay/DependencyCreationOverlay.tsx
@@ -6447,7 +6661,7 @@ var DependencyCreationOverlay = ({ drag, width, height }) => {
 };
 
 // src/components/TaskList/TaskList.tsx
-import React14, { useMemo as useMemo10, useCallback as useCallback6, useState as useState8, useEffect as useEffect8, useRef as useRef8 } from "react";
+import React14, { useMemo as useMemo10, useCallback as useCallback7, useState as useState8, useEffect as useEffect8, useRef as useRef9 } from "react";
 
 // src/utils/taskListReorder.ts
 function getDescendantIds(taskId, tasks) {
@@ -6653,9 +6867,9 @@ var PopoverContent = ({
 // src/components/TaskList/TaskListRow.tsx
 import React11, {
   useState as useState6,
-  useRef as useRef5,
+  useRef as useRef6,
   useEffect as useEffect6,
-  useCallback as useCallback5,
+  useCallback as useCallback6,
   useMemo as useMemo9
 } from "react";
 
@@ -6677,15 +6891,15 @@ var Input = React8.forwardRef(
 Input.displayName = "Input";
 
 // src/components/ui/DatePicker.tsx
-import { useState as useState5, useCallback as useCallback4, useEffect as useEffect5, useRef as useRef4 } from "react";
+import { useState as useState5, useCallback as useCallback5, useEffect as useEffect5, useRef as useRef5 } from "react";
 import { format as format3, isValid, parse, addDays, addMonths as addMonths2, addYears, subMonths as subMonths2, subYears, subDays } from "date-fns";
 
 // src/components/ui/Calendar.tsx
 import {
   useState as useState4,
-  useRef as useRef3,
+  useRef as useRef4,
   useEffect as useEffect4,
-  useCallback as useCallback3,
+  useCallback as useCallback4,
   useMemo as useMemo8
 } from "react";
 import {
@@ -6719,7 +6933,7 @@ var Calendar = ({
   disabled = false,
   isWeekend: isWeekendProp
 }) => {
-  const scrollRef = useRef3(null);
+  const scrollRef = useRef4(null);
   const initialMonth = useMemo8(
     () => startOfMonth(initialDate ?? selected ?? /* @__PURE__ */ new Date()),
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -6730,7 +6944,7 @@ var Calendar = ({
     initialMonth,
     addMonths(initialMonth, 1)
   ]);
-  const loadMoreMonths = useCallback3((direction) => {
+  const loadMoreMonths = useCallback4((direction) => {
     setMonths((prev) => {
       if (direction === "up") {
         return [subMonths(prev[0], 1), ...prev];
@@ -6766,7 +6980,7 @@ var Calendar = ({
       el.scrollIntoView({ behavior: "auto", block: "start" });
     }
   }, []);
-  const renderMonth = useCallback3(
+  const renderMonth = useCallback4(
     (month) => {
       const firstDay = startOfMonth(month);
       const totalDays = getDaysInMonth(month);
@@ -6865,9 +7079,9 @@ var DatePicker = ({
   const [open, setOpen] = useState5(false);
   const [inputValue, setInputValue] = useState5("");
   const [draftDate, setDraftDate] = useState5(void 0);
-  const dateInputRef = useRef4(null);
-  const segIdxRef = useRef4(0);
-  const charPosRef = useRef4(0);
+  const dateInputRef = useRef5(null);
+  const segIdxRef = useRef5(0);
+  const charPosRef = useRef5(0);
   const selectedDate = (() => {
     if (!value) return void 0;
     const d = /* @__PURE__ */ new Date(value + "T00:00:00Z");
@@ -6887,7 +7101,7 @@ var DatePicker = ({
       setDraftDate(void 0);
     }
   }, [value]);
-  const selectSegByIdx = useCallback4((idx) => {
+  const selectSegByIdx = useCallback5((idx) => {
     if (!dateInputRef.current) return;
     const seg = segments[idx] ?? segments[0];
     dateInputRef.current.setSelectionRange(seg.start, seg.end);
@@ -6920,18 +7134,18 @@ var DatePicker = ({
       selectSegByIdx(segIdxRef.current);
     }, 0);
   };
-  const handleShiftButtonMouseDown = useCallback4(
+  const handleShiftButtonMouseDown = useCallback5(
     (e) => {
       e.preventDefault();
     },
     []
   );
-  const updateFromDate = useCallback4((newDate) => {
+  const updateFromDate = useCallback5((newDate) => {
     if (!isValid(newDate)) return;
     setInputValue(formatUTCDate(newDate, "dd.MM.yy"));
     setDraftDate(newDate);
   }, []);
-  const commitDate = useCallback4((dateToCommit) => {
+  const commitDate = useCallback5((dateToCommit) => {
     const nextDate = dateToCommit ?? draftDate ?? selectedDate;
     if (!nextDate || !isValid(nextDate)) return;
     const iso = [
@@ -6942,7 +7156,7 @@ var DatePicker = ({
     if (iso === value) return;
     onChange?.(iso);
   }, [draftDate, onChange, selectedDate, value]);
-  const handleCalendarSelect = useCallback4(
+  const handleCalendarSelect = useCallback5(
     (day) => {
       const normalizedDay = businessDays && isWeekend3 && isWeekend3(day) ? snapToBusinessDay(day, 1, isWeekend3) : day;
       updateFromDate(normalizedDay);
@@ -6951,7 +7165,7 @@ var DatePicker = ({
     },
     [businessDays, commitDate, isWeekend3, updateFromDate]
   );
-  const handleDayShift = useCallback4(
+  const handleDayShift = useCallback5(
     (delta) => {
       const base = activeDate ?? /* @__PURE__ */ new Date();
       if (businessDays && isWeekend3) {
@@ -6962,7 +7176,7 @@ var DatePicker = ({
     },
     [activeDate, updateFromDate, businessDays, isWeekend3]
   );
-  const handleTriggerKeyDown = useCallback4((e) => {
+  const handleTriggerKeyDown = useCallback5((e) => {
     if (disabled) return;
     if (e.key === "ArrowUp") {
       e.preventDefault();
@@ -6976,7 +7190,7 @@ var DatePicker = ({
       handleDayShift(-1);
     }
   }, [disabled, handleDayShift]);
-  const handleKeyDown = useCallback4((e) => {
+  const handleKeyDown = useCallback5((e) => {
     if (!dateInputRef.current) return;
     const { value: inputVal } = dateInputRef.current;
     const segIdx = segIdxRef.current;
@@ -7077,7 +7291,7 @@ var DatePicker = ({
       }
     }
   }, [activeDate, businessDays, commitDate, isWeekend3, selectSegByIdx, updateFromDate]);
-  const handleOpenChange = useCallback4((nextOpen) => {
+  const handleOpenChange = useCallback5((nextOpen) => {
     if (!nextOpen && open) {
       commitDate();
     }
@@ -7513,7 +7727,7 @@ var DepChip = ({
       onChipSelect?.(null);
     }
   };
-  const handleOpenChange = useCallback5(
+  const handleOpenChange = useCallback6(
     (open) => {
       setPopoverOpen(open);
     },
@@ -7525,7 +7739,7 @@ var DepChip = ({
     onChipSelectClear();
     setPopoverOpen(false);
   };
-  const handleLagChange = useCallback5(
+  const handleLagChange = useCallback6(
     (newLag) => {
       if (!onTasksChange || !allTasks) return;
       const taskById = new Map(allTasks.map((t) => [t.id, t]));
@@ -7585,7 +7799,7 @@ var DepChip = ({
     },
     [dep, task, allTasks, onTasksChange, businessDays, weekendPredicate]
   );
-  const handleInputCommit = useCallback5(
+  const handleInputCommit = useCallback6(
     (raw) => {
       if (raw === "") {
         handleLagChange(0);
@@ -7901,7 +8115,7 @@ var TaskListRow = React11.memo(
         })
       );
     }, [resolvedColumns]);
-    const getColumnStyle = useCallback5((columnId, fallbackWidth) => {
+    const getColumnStyle = useCallback6((columnId, fallbackWidth) => {
       return columnWidthStyleMap.get(columnId) ?? {
         width: fallbackWidth,
         minWidth: fallbackWidth,
@@ -7912,26 +8126,26 @@ var TaskListRow = React11.memo(
     const normalizedTask = useMemo9(() => normalizeTaskDatesForType(task), [task]);
     const isMilestone = useMemo9(() => isMilestoneTask(normalizedTask), [normalizedTask]);
     const [nameValue, setNameValue] = useState6("");
-    const nameInputRef = useRef5(null);
+    const nameInputRef = useRef6(null);
     const [durationValue, setDurationValue] = useState6(
       () => getInclusiveDurationDays(normalizedTask.startDate, normalizedTask.endDate)
     );
-    const durationInputRef = useRef5(null);
-    const dependencySearchInputRef = useRef5(null);
-    const dependencySearchListRef = useRef5(null);
+    const durationInputRef = useRef6(null);
+    const dependencySearchInputRef = useRef6(null);
+    const dependencySearchListRef = useRef6(null);
     const [progressValue, setProgressValue] = useState6(0);
-    const progressInputRef = useRef5(null);
+    const progressInputRef = useRef6(null);
     const [overflowOpen, setOverflowOpen] = useState6(false);
     const [contextMenuOpen, setContextMenuOpen] = useState6(false);
     const [colorMenuOpen, setColorMenuOpen] = useState6(false);
-    const nameConfirmedRef = useRef5(false);
-    const durationConfirmedRef = useRef5(false);
-    const progressConfirmedRef = useRef5(false);
-    const autoEditedForRef = useRef5(null);
-    const editTriggerRef = useRef5(
+    const nameConfirmedRef = useRef6(false);
+    const durationConfirmedRef = useRef6(false);
+    const progressConfirmedRef = useRef6(false);
+    const autoEditedForRef = useRef6(null);
+    const editTriggerRef = useRef6(
       "doubleclick"
     );
-    const rowRef = useRef5(null);
+    const rowRef = useRef6(null);
     const isSelected = selectedTaskId === task.id;
     const isParent = useMemo9(
       () => isTaskParent(task.id, allTasks),
@@ -7945,13 +8159,13 @@ var TaskListRow = React11.memo(
       () => createCustomDayPredicate({ customDays, isWeekend: isWeekend3 }),
       [customDays, isWeekend3]
     );
-    const getDuration = useCallback5(
+    const getDuration = useCallback6(
       (start, end) => {
         return businessDays ? getBusinessDaysCount(start, end, weekendPredicate) : getInclusiveDurationDays(start, end);
       },
       [businessDays, weekendPredicate]
     );
-    const getEndDate = useCallback5(
+    const getEndDate = useCallback6(
       (start, duration) => {
         return businessDays ? addBusinessDays(start, duration, weekendPredicate).toISOString().split("T")[0] : getEndDateFromDuration(start, duration);
       },
@@ -7961,7 +8175,7 @@ var TaskListRow = React11.memo(
     const [compositeIconMode, setCompositeIconMode] = useState6(
       () => isCollapsed ? "composite" : "down"
     );
-    const compositeIconModeRef = useRef5(compositeIconMode);
+    const compositeIconModeRef = useRef6(compositeIconMode);
     const [compositeIconAnimation, setCompositeIconAnimation] = useState6(null);
     const [compositeIconAnimationPhase, setCompositeIconAnimationPhase] = useState6(null);
     useEffect6(() => {
@@ -7987,7 +8201,7 @@ var TaskListRow = React11.memo(
         window.clearTimeout(finishTimeoutId);
       };
     }, [isCollapsed]);
-    const getHierarchyLineColor = useCallback5((columnDepth) => {
+    const getHierarchyLineColor = useCallback6((columnDepth) => {
       return columnDepth % 2 === 0 ? "#93c5fd" : "var(--gantt-hierarchy-line-color)";
     }, []);
     const isPicking = selectingPredecessorFor != null;
@@ -8085,7 +8299,7 @@ var TaskListRow = React11.memo(
         setEditingColumnId("name");
       }
     }, [editingTaskId, task.id, disableTaskNameEditing]);
-    const handleNameClick = useCallback5(
+    const handleNameClick = useCallback6(
       (e) => {
         e.stopPropagation();
         onRowClick?.(task.id);
@@ -8093,7 +8307,7 @@ var TaskListRow = React11.memo(
       },
       [task.id, onRowClick, onScrollToTask]
     );
-    const handleNameDoubleClick = useCallback5(
+    const handleNameDoubleClick = useCallback6(
       (e) => {
         if (task.composite) return;
         if (disableTaskNameEditing) return;
@@ -8105,7 +8319,7 @@ var TaskListRow = React11.memo(
       },
       [task.name, task.composite, disableTaskNameEditing]
     );
-    const handleRowKeyDown = useCallback5(
+    const handleRowKeyDown = useCallback6(
       (e) => {
         if (editingProgress) return;
         if (!editingName && !disableTaskNameEditing && e.key === "F2") {
@@ -8119,7 +8333,7 @@ var TaskListRow = React11.memo(
       },
       [editingName, disableTaskNameEditing, task.name]
     );
-    const handleNameSave = useCallback5(() => {
+    const handleNameSave = useCallback6(() => {
       if (nameConfirmedRef.current) {
         nameConfirmedRef.current = false;
         return;
@@ -8129,10 +8343,10 @@ var TaskListRow = React11.memo(
       }
       setEditingColumnId(null);
     }, [nameValue, task, onTasksChange]);
-    const handleNameCancel = useCallback5(() => {
+    const handleNameCancel = useCallback6(() => {
       setEditingColumnId(null);
     }, []);
-    const handleNameKeyDown = useCallback5(
+    const handleNameKeyDown = useCallback6(
       (e) => {
         if (e.key === "Enter") {
           nameConfirmedRef.current = true;
@@ -8146,7 +8360,7 @@ var TaskListRow = React11.memo(
       },
       [nameValue, task, onTasksChange, handleNameCancel]
     );
-    const handleDurationClick = useCallback5(
+    const handleDurationClick = useCallback6(
       (e) => {
         if (task.locked) return;
         e.stopPropagation();
@@ -8158,11 +8372,11 @@ var TaskListRow = React11.memo(
       },
       [task.locked, normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]
     );
-    const applyDurationChange = useCallback5((nextDuration) => {
+    const applyDurationChange = useCallback6((nextDuration) => {
       const normalizedDuration = Math.max(0, Math.round(nextDuration) || 0);
       setDurationValue(normalizedDuration);
     }, []);
-    const emitDurationChange = useCallback5((rounded) => {
+    const emitDurationChange = useCallback6((rounded) => {
       if (onDurationChange) {
         onDurationChange(
           isMilestone && rounded > 0 ? { ...task, type: "task" } : !isMilestone && rounded === 0 ? { ...task, type: "milestone", endDate: task.startDate } : task,
@@ -8184,7 +8398,7 @@ var TaskListRow = React11.memo(
         ]);
       }
     }, [getEndDate, isMilestone, onDurationChange, onTasksChange, task]);
-    const handleDurationSave = useCallback5(() => {
+    const handleDurationSave = useCallback6(() => {
       if (durationConfirmedRef.current) {
         durationConfirmedRef.current = false;
         return;
@@ -8193,17 +8407,17 @@ var TaskListRow = React11.memo(
       emitDurationChange(rounded);
       setEditingColumnId(null);
     }, [durationValue, emitDurationChange]);
-    const handleDurationCancel = useCallback5(() => {
+    const handleDurationCancel = useCallback6(() => {
       setDurationValue(isMilestone ? 0 : getDuration(normalizedTask.startDate, normalizedTask.endDate));
       setEditingColumnId(null);
     }, [normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]);
-    const handleDurationAdjust = useCallback5(
+    const handleDurationAdjust = useCallback6(
       (delta) => {
         applyDurationChange(durationValue + delta);
       },
       [applyDurationChange, durationValue]
     );
-    const handleDurationKeyDown = useCallback5(
+    const handleDurationKeyDown = useCallback6(
       (e) => {
         e.stopPropagation();
         if (e.key === "Enter") {
@@ -8217,7 +8431,7 @@ var TaskListRow = React11.memo(
       },
       [durationValue, emitDurationChange, handleDurationCancel]
     );
-    const handleProgressClick = useCallback5(
+    const handleProgressClick = useCallback6(
       (e) => {
         if (task.locked) return;
         e.stopPropagation();
@@ -8227,7 +8441,7 @@ var TaskListRow = React11.memo(
       },
       [task.progress, task.locked]
     );
-    const handleProgressSave = useCallback5(() => {
+    const handleProgressSave = useCallback6(() => {
       if (progressConfirmedRef.current) {
         progressConfirmedRef.current = false;
         return;
@@ -8236,15 +8450,15 @@ var TaskListRow = React11.memo(
       onTasksChange?.(cascadeTaskProgress({ ...task, progress: clampedValue }, allTasks));
       setEditingColumnId(null);
     }, [progressValue, task, onTasksChange, allTasks]);
-    const handleProgressCancel = useCallback5(() => {
+    const handleProgressCancel = useCallback6(() => {
       setEditingColumnId(null);
     }, []);
-    const handleProgressAdjust = useCallback5((delta) => {
+    const handleProgressAdjust = useCallback6((delta) => {
       setProgressValue(
         (current) => Math.max(0, Math.min(100, current + delta))
       );
     }, []);
-    const handleProgressKeyDown = useCallback5(
+    const handleProgressKeyDown = useCallback6(
       (e) => {
         e.stopPropagation();
         if (e.key === "Enter") {
@@ -8273,7 +8487,7 @@ var TaskListRow = React11.memo(
         durationInputRef.current.select();
       }
     }, [editingDuration]);
-    const emitMilestoneDateChange = useCallback5((nextDateISO) => {
+    const emitMilestoneDateChange = useCallback6((nextDateISO) => {
       const alignedDate = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${nextDateISO}T00:00:00.000Z`), 1, weekendPredicate) : /* @__PURE__ */ new Date(`${nextDateISO}T00:00:00.000Z`);
       const clampedRange = clampTaskRangeForIncomingFS(
         task,
@@ -8306,7 +8520,7 @@ var TaskListRow = React11.memo(
         }
       ]);
     }, [task, onTasksChange, allTasks, businessDays, weekendPredicate]);
-    const handleStartDateChange = useCallback5(
+    const handleStartDateChange = useCallback6(
       (newDateISO) => {
         if (!newDateISO) return;
         if (isMilestone) {
@@ -8359,7 +8573,7 @@ var TaskListRow = React11.memo(
       },
       [task, onTasksChange, businessDays, getDuration, allTasks, weekendPredicate, isMilestone, emitMilestoneDateChange, taskDateChangeMode]
     );
-    const handleEndDateChange = useCallback5(
+    const handleEndDateChange = useCallback6(
       (newDateISO) => {
         if (!newDateISO) return;
         if (isMilestone) {
@@ -8423,41 +8637,41 @@ var TaskListRow = React11.memo(
       ),
       /* @__PURE__ */ jsx15("span", { children: "\u0421\u043E\u0445\u0440\u0430\u043D\u044F\u0442\u044C \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C" })
     ] }) : null;
-    const handleRowClickInternal = useCallback5(() => {
+    const handleRowClickInternal = useCallback6(() => {
       onRowClick?.(task.id);
     }, [task.id, onRowClick]);
-    const handleNumberClick = useCallback5(
+    const handleNumberClick = useCallback6(
       (e) => {
         e.stopPropagation();
         onRowClick?.(task.id);
       },
       [task.id, onRowClick]
     );
-    const handleToggleCollapse = useCallback5(
+    const handleToggleCollapse = useCallback6(
       (e) => {
         e.stopPropagation();
         onToggleCollapse?.(task.id);
       },
       [task.id, onToggleCollapse]
     );
-    const handlePromote = useCallback5(
+    const handlePromote = useCallback6(
       (e) => {
         e.stopPropagation();
         onPromoteTask?.(task.id);
       },
       [task.id, onPromoteTask]
     );
-    const handleDemote = useCallback5(
+    const handleDemote = useCallback6(
       (e) => {
         e.stopPropagation();
         onDemoteTask?.(task.id, "");
       },
       [task.id, onDemoteTask]
     );
-    const closeColorMenu = useCallback5(() => {
+    const closeColorMenu = useCallback6(() => {
       setColorMenuOpen(false);
     }, []);
-    const handleApplyColor = useCallback5(
+    const handleApplyColor = useCallback6(
       (color) => {
         if (!onTasksChange) return;
         const descendantIds = new Set(
@@ -8473,7 +8687,7 @@ var TaskListRow = React11.memo(
       },
       [allTasks, closeColorMenu, isParent, onTasksChange, task]
     );
-    const handleUngroup = useCallback5(
+    const handleUngroup = useCallback6(
       (e) => {
         e.stopPropagation();
         setContextMenuOpen(false);
@@ -8494,7 +8708,7 @@ var TaskListRow = React11.memo(
       [taskListMenuCommands, task, isParent, isMilestoneRow]
     );
     const hasContextMenu = !hideTaskListRowActions && (visibleCustomMenuCommands.length > 0 || !!onDuplicateTask || !!onDelete || !!onTasksChange || isParent && !!onUngroupTask);
-    const handleCustomMenuCommandClick = useCallback5(
+    const handleCustomMenuCommandClick = useCallback6(
       (command) => (e) => {
         e.stopPropagation();
         if (command.closeOnSelect !== false) {
@@ -8505,14 +8719,14 @@ var TaskListRow = React11.memo(
       },
       [closeColorMenu, task]
     );
-    const handleAddClick = useCallback5(
+    const handleAddClick = useCallback6(
       (e) => {
         e.stopPropagation();
         onSetSelectingPredecessorFor?.(task.id);
       },
       [task.id, onSetSelectingPredecessorFor]
     );
-    const handlePredecessorPick = useCallback5(
+    const handlePredecessorPick = useCallback6(
       (e) => {
         e.stopPropagation();
         if (!isPicking || isSourceRow) return;
@@ -8533,14 +8747,14 @@ var TaskListRow = React11.memo(
         onAddDependency
       ]
     );
-    const handleCancelPicking = useCallback5(
+    const handleCancelPicking = useCallback6(
       (e) => {
         e.stopPropagation();
         onSetSelectingPredecessorFor?.(null);
       },
       [onSetSelectingPredecessorFor]
     );
-    const handleSourceCellClick = useCallback5(
+    const handleSourceCellClick = useCallback6(
       (e) => {
         if (e.target === e.currentTarget) {
           handleCancelPicking(e);
@@ -8548,7 +8762,7 @@ var TaskListRow = React11.memo(
       },
       [handleCancelPicking]
     );
-    const handleSearchPick = useCallback5(
+    const handleSearchPick = useCallback6(
       (pickedTaskId) => {
         if (!activeLinkType) return;
         if (dependencyPickMode === "predecessor") {
@@ -8559,7 +8773,7 @@ var TaskListRow = React11.memo(
       },
       [activeLinkType, dependencyPickMode, onAddDependency, task.id]
     );
-    const handleSearchRemove = useCallback5(
+    const handleSearchRemove = useCallback6(
       (pickedTaskId) => {
         const matchingTypes = dependencyPickMode === "predecessor" ? (task.dependencies ?? []).filter((dep) => dep.taskId === pickedTaskId).map((dep) => dep.type) : (allTasks.find((candidate) => candidate.id === pickedTaskId)?.dependencies ?? []).filter((dep) => dep.taskId === task.id).map((dep) => dep.type);
         for (const linkType of matchingTypes) {
@@ -9526,7 +9740,7 @@ var TaskListRow = React11.memo(
       progress: progressCell,
       dependencies: dependenciesCell
     };
-    const focusCustomCell = useCallback5((taskId, columnId) => {
+    const focusCustomCell = useCallback6((taskId, columnId) => {
       const overlay = rowRef.current?.closest(".gantt-tl-overlay");
       if (!overlay) {
         return;
@@ -9535,7 +9749,7 @@ var TaskListRow = React11.memo(
       const nextCell = overlay.querySelector(selector);
       nextCell?.focus();
     }, []);
-    const moveActiveCustomCell = useCallback5((columnId, direction) => {
+    const moveActiveCustomCell = useCallback6((columnId, direction) => {
       const overlay = rowRef.current?.closest(".gantt-tl-overlay");
       if (!overlay || !resolvedColumns) {
         return;
@@ -9739,7 +9953,7 @@ var TaskListRow = React11.memo(
 TaskListRow.displayName = "TaskListRow";
 
 // src/components/TaskList/NewTaskRow.tsx
-import { useState as useState7, useRef as useRef6, useEffect as useEffect7 } from "react";
+import { useState as useState7, useRef as useRef7, useEffect as useEffect7 } from "react";
 import { jsx as jsx16, jsxs as jsxs11 } from "react/jsx-runtime";
 var NewTaskRow = ({
   rowHeight,
@@ -9748,8 +9962,8 @@ var NewTaskRow = ({
   nestingDepth = 0
 }) => {
   const [nameValue, setNameValue] = useState7("");
-  const inputRef = useRef6(null);
-  const confirmedRef = useRef6(false);
+  const inputRef = useRef7(null);
+  const confirmedRef = useRef7(false);
   const inputInnerPadding = 4;
   const levelOffset = nestingDepth > 0 ? nestingDepth * 20 + 8 : 0;
   useEffect7(() => {
@@ -9805,7 +10019,7 @@ var NewTaskRow = ({
 };
 
 // src/components/GenerationSkeleton/GenerationSkeleton.tsx
-import { useRef as useRef7 } from "react";
+import { useRef as useRef8 } from "react";
 import { Fragment as Fragment5, jsx as jsx17 } from "react/jsx-runtime";
 var MAX_SKELETON_ROWS = 200;
 var SHIMMER_DURATION_MS = 1450;
@@ -9830,8 +10044,8 @@ var GenerationSkeletonRows = ({
   chartStartJitterDays = 0
 }) => {
   const safeCount = clampCount(count);
-  const previousCountRef = useRef7(null);
-  const shimmerDelayRef = useRef7("0ms");
+  const previousCountRef = useRef8(null);
+  const shimmerDelayRef = useRef8("0ms");
   if (previousCountRef.current !== safeCount) {
     previousCountRef.current = safeCount;
     shimmerDelayRef.current = `-${Date.now() % SHIMMER_DURATION_MS}ms`;
@@ -10102,7 +10316,7 @@ var SelectAllCheckbox = ({
   indeterminate,
   onChange
 }) => {
-  const ref = useRef8(null);
+  const ref = useRef9(null);
   useEffect8(() => {
     if (ref.current) {
       ref.current.indeterminate = indeterminate;
@@ -10188,8 +10402,8 @@ var TaskList = ({
   const [activeCustomCell, setActiveCustomCell] = useState8(null);
   const [columnWidthOverrides, setColumnWidthOverrides] = useState8(() => normalizeColumnWidthMap(taskListColumnWidths));
   const [isColumnResizeMode, setIsColumnResizeMode] = useState8(false);
-  const columnResizeHeaderRef = useRef8(null);
-  const resizeStateRef = useRef8(null);
+  const columnResizeHeaderRef = useRef9(null);
+  const resizeStateRef = useRef9(null);
   const effectiveSelectedTaskIds = selectedTaskIds ?? internalSelectedTaskIds;
   useEffect8(() => {
     if (!isColumnResizeMode) {
@@ -10207,7 +10421,7 @@ var TaskList = ({
       document.removeEventListener("pointerdown", handleOutsidePointerDown);
     };
   }, [isColumnResizeMode]);
-  const emitSelectedTaskIdsChange = useCallback6((nextSelectedTaskIds) => {
+  const emitSelectedTaskIdsChange = useCallback7((nextSelectedTaskIds) => {
     if (!selectedTaskIds) {
       setInternalSelectedTaskIds(nextSelectedTaskIds);
     }
@@ -10215,7 +10429,7 @@ var TaskList = ({
   }, [onSelectedTaskIdsChange, selectedTaskIds]);
   const [internalCollapsedParentIds, setInternalCollapsedParentIds] = useState8(/* @__PURE__ */ new Set());
   const collapsedParentIds = externalCollapsedParentIds ?? internalCollapsedParentIds;
-  const handleToggleCollapse = externalOnToggleCollapse ?? useCallback6((parentId) => {
+  const handleToggleCollapse = externalOnToggleCollapse ?? useCallback7((parentId) => {
     setInternalCollapsedParentIds((prev) => {
       const next = new Set(prev);
       if (next.has(parentId)) {
@@ -10286,7 +10500,7 @@ var TaskList = ({
   );
   const areAllVisibleTasksSelected = visibleTaskIds.length > 0 && selectedVisibleTaskCount === visibleTaskIds.length;
   const areSomeVisibleTasksSelected = selectedVisibleTaskCount > 0 && !areAllVisibleTasksSelected;
-  const handleToggleTaskSelection = useCallback6((taskId, checked) => {
+  const handleToggleTaskSelection = useCallback7((taskId, checked) => {
     const nextSelectedTaskIds = new Set(effectiveSelectedTaskIds);
     if (checked) {
       nextSelectedTaskIds.add(taskId);
@@ -10295,7 +10509,7 @@ var TaskList = ({
     }
     emitSelectedTaskIdsChange(nextSelectedTaskIds);
   }, [effectiveSelectedTaskIds, emitSelectedTaskIdsChange]);
-  const handleToggleAllVisibleTaskSelection = useCallback6((checked) => {
+  const handleToggleAllVisibleTaskSelection = useCallback7((checked) => {
     const nextSelectedTaskIds = new Set(effectiveSelectedTaskIds);
     for (const taskId of visibleTaskIds) {
       if (checked) {
@@ -10376,7 +10590,7 @@ var TaskList = ({
     }
     return map;
   }, [tasks, visibleTasks]);
-  const handleRowClick = useCallback6((taskId) => {
+  const handleRowClick = useCallback7((taskId) => {
     onTaskSelect?.(taskId);
   }, [onTaskSelect]);
   const [activeLinkType, setActiveLinkType] = useState8("FS");
@@ -10384,14 +10598,14 @@ var TaskList = ({
   const [dependencyPickMode, setDependencyPickMode] = useState8("successor");
   const [typeMenuOpen, setTypeMenuOpen] = useState8(false);
   const [dependencyError, setDependencyError] = useState8(null);
-  const overlayRef = useRef8(null);
+  const overlayRef = useRef9(null);
   const [selectedChip, setSelectedChip] = useState8(controlledSelectedChip ? { ...controlledSelectedChip, linkType: controlledSelectedChip.linkType } : null);
   useEffect8(() => {
     if (controlledSelectedChip !== void 0) {
       setSelectedChip(controlledSelectedChip ? { ...controlledSelectedChip, linkType: controlledSelectedChip.linkType } : null);
     }
   }, [controlledSelectedChip]);
-  const handleChipSelect = useCallback6((chip) => {
+  const handleChipSelect = useCallback7((chip) => {
     setSelectedChip(chip);
     onSelectedChipChange?.(chip);
   }, [onSelectedChipChange]);
@@ -10490,7 +10704,7 @@ var TaskList = ({
       document.removeEventListener("mouseup", handleCanvasMouseUp, true);
     };
   }, [selectingPredecessorFor, selectedChip, selectedTaskId, activeCustomCell, onTaskSelect, onSelectedChipChange]);
-  const handleAddDependency = useCallback6((successorTaskId, predecessorTaskId, linkType) => {
+  const handleAddDependency = useCallback7((successorTaskId, predecessorTaskId, linkType) => {
     if (successorTaskId === predecessorTaskId) return;
     if (areTasksHierarchicallyRelated(successorTaskId, predecessorTaskId, tasks)) {
       setDependencyError("\u0421\u0432\u044F\u0437\u0438 \u043C\u0435\u0436\u0434\u0443 \u0440\u043E\u0434\u0438\u0442\u0435\u043B\u0435\u043C \u0438 \u043F\u043E\u0442\u043E\u043C\u043A\u043E\u043C \u0437\u0430\u043F\u0440\u0435\u0449\u0435\u043D\u044B");
@@ -10569,7 +10783,7 @@ var TaskList = ({
     }
     setSelectingPredecessorFor(null);
   }, [tasks, onTasksChange]);
-  const handleRemoveDependency = useCallback6((taskId, predecessorTaskId, linkType) => {
+  const handleRemoveDependency = useCallback7((taskId, predecessorTaskId, linkType) => {
     const task = tasks.find((t) => t.id === taskId);
     if (!task) return;
     const updatedDeps = (task.dependencies ?? []).filter(
@@ -10582,16 +10796,16 @@ var TaskList = ({
   const [draggingIndex, setDraggingIndex] = useState8(null);
   const [dragOverTarget, setDragOverTarget] = useState8(null);
   const [isBeforeFirstDropZoneActive, setIsBeforeFirstDropZoneActive] = useState8(false);
-  const dragOriginIndexRef = useRef8(null);
-  const dragTaskIdRef = useRef8(null);
-  const clearDragState = useCallback6(() => {
+  const dragOriginIndexRef = useRef9(null);
+  const dragTaskIdRef = useRef9(null);
+  const clearDragState = useCallback7(() => {
     setDraggingIndex(null);
     setDragOverTarget(null);
     setIsBeforeFirstDropZoneActive(false);
     dragOriginIndexRef.current = null;
     dragTaskIdRef.current = null;
   }, []);
-  const isValidParentDrop = useCallback6((draggedTaskId, dropIndex) => {
+  const isValidParentDrop = useCallback7((draggedTaskId, dropIndex) => {
     if (!isTaskParent(draggedTaskId, tasks)) {
       return true;
     }
@@ -10609,13 +10823,13 @@ var TaskList = ({
     }
     return true;
   }, [tasks, visibleTasks, orderedTasks]);
-  const handleDragStart = useCallback6((index, e) => {
+  const handleDragStart = useCallback7((index, e) => {
     e.dataTransfer.effectAllowed = "move";
     setDraggingIndex(index);
     dragOriginIndexRef.current = index;
     dragTaskIdRef.current = visibleTasks[index]?.id ?? null;
   }, [visibleTasks]);
-  const normalizeDropTarget = useCallback6((movedTaskId, target) => {
+  const normalizeDropTarget = useCallback7((movedTaskId, target) => {
     if (target.placement !== "before" || target.index <= 0 || target.index >= visibleTasks.length) {
       return target;
     }
@@ -10638,7 +10852,7 @@ var TaskList = ({
     }
     return target;
   }, [orderedTasks, visibleTasks]);
-  const handleDragOver = useCallback6((index, e, forcedPlacement) => {
+  const handleDragOver = useCallback7((index, e, forcedPlacement) => {
     e.preventDefault();
     const draggedTaskId = dragTaskIdRef.current;
     if (!draggedTaskId) return;
@@ -10690,7 +10904,7 @@ var TaskList = ({
       isDirectChildDrop: normalizedTarget.placement === "after" && reorderPlan.inferredParentId === targetTask.id
     });
   }, [isValidParentDrop, normalizeDropTarget, orderedTasks, visibleTasks]);
-  const handleDrop = useCallback6((dropIndex, e, forcedPlacement) => {
+  const handleDrop = useCallback7((dropIndex, e, forcedPlacement) => {
     e.preventDefault();
     const originVisibleIndex = dragOriginIndexRef.current;
     const movedTaskId = dragTaskIdRef.current;
@@ -10757,7 +10971,7 @@ var TaskList = ({
     onTaskSelect?.(moved.id);
     clearDragState();
   }, [orderedTasks, visibleTasks, onReorder, onTaskSelect, isValidParentDrop, clearDragState, normalizeDropTarget]);
-  const handleBeforeFirstDragOver = useCallback6((e) => {
+  const handleBeforeFirstDragOver = useCallback7((e) => {
     const draggedTaskId = dragTaskIdRef.current;
     const firstTask = visibleTasks[0];
     const descendantIds = draggedTaskId ? new Set(getAllDescendants2(draggedTaskId, orderedTasks).map((task) => task.id)) : /* @__PURE__ */ new Set();
@@ -10765,11 +10979,11 @@ var TaskList = ({
     setIsBeforeFirstDropZoneActive(isValidBeforeFirstDrop);
     handleDragOver(0, e, "before");
   }, [handleDragOver, isValidParentDrop, orderedTasks, visibleTasks]);
-  const handleDragEnd = useCallback6(() => {
+  const handleDragEnd = useCallback7(() => {
     clearDragState();
   }, [clearDragState]);
   const shouldShowBeforeFirstDropZone = !reorderDisabled && visibleTasks.length > 0 && draggingIndex !== null && draggingIndex > 0;
-  const handleConfirmNewTask = useCallback6((name) => {
+  const handleConfirmNewTask = useCallback7((name) => {
     const range = buildDefaultTaskDateRange(getTodayISODate(), {
       businessDays,
       defaultTaskDurationDays,
@@ -10784,8 +10998,8 @@ var TaskList = ({
     onAdd?.(newTask);
     setIsCreating(false);
   }, [businessDays, defaultTaskDurationDays, onAdd, weekendPredicate]);
-  const handleCancelNewTask = useCallback6(() => setIsCreating(false), []);
-  const findInsertAfterTaskId = useCallback6((anchorTaskId) => {
+  const handleCancelNewTask = useCallback7(() => setIsCreating(false), []);
+  const findInsertAfterTaskId = useCallback7((anchorTaskId) => {
     const anchorIndex = orderedTasks.findIndex((task) => task.id === anchorTaskId);
     if (anchorIndex === -1) {
       return anchorTaskId;
@@ -10835,7 +11049,7 @@ var TaskList = ({
     [pendingInsertDisplayTaskId, visibleTasks]
   );
   const hasVisiblePendingInsert = pendingInsertRowIndex >= 0;
-  const handleStartInsertAfter = useCallback6((taskId, newTask) => {
+  const handleStartInsertAfter = useCallback7((taskId, newTask) => {
     const anchorTask = orderedTasks.find((task) => task.id === taskId);
     if (!anchorTask) {
       return;
@@ -10850,7 +11064,7 @@ var TaskList = ({
       nestingDepth: nestingDepthMap.get(taskId) ?? 0
     });
   }, [findInsertAfterTaskId, nestingDepthMap, orderedTasks]);
-  const handleConfirmInsertedTask = useCallback6((name) => {
+  const handleConfirmInsertedTask = useCallback7((name) => {
     if (!pendingInsert) {
       return;
     }
@@ -10864,7 +11078,7 @@ var TaskList = ({
     onInsertAfter?.(pendingInsert.insertAfterTaskId, newTask);
     setPendingInsert(null);
   }, [onInsertAfter, pendingInsert]);
-  const handleCancelInsertedTask = useCallback6(() => setPendingInsert(null), []);
+  const handleCancelInsertedTask = useCallback7(() => setPendingInsert(null), []);
   function getTaskDepth(task, tasks2) {
     if (!task) return 0;
     let depth = 0;
@@ -10877,7 +11091,7 @@ var TaskList = ({
     }
     return depth;
   }
-  const handleDemoteWrapper = useCallback6((taskId, _newParentId) => {
+  const handleDemoteWrapper = useCallback7((taskId, _newParentId) => {
     const taskIndex = visibleTasks.findIndex((t) => t.id === taskId);
     const currentTask = visibleTasks[taskIndex];
     const currentDepth = getTaskDepth(currentTask, orderedTasks);
@@ -10911,7 +11125,7 @@ var TaskList = ({
     ];
     onReorder?.(updatedTasks, taskId, newSectionTask.id);
   }, [visibleTasks, orderedTasks, onDemoteTask, onReorder]);
-  const handleDuplicateTask = useCallback6((taskId) => {
+  const handleDuplicateTask = useCallback7((taskId) => {
     const duplicatedTasks = duplicateTaskSubtree(taskId, orderedTasks);
     onReorder?.(duplicatedTasks);
   }, [orderedTasks, onReorder]);
@@ -10961,7 +11175,7 @@ var TaskList = ({
   const requestedTaskListWidth = taskListWidth ?? Math.min(MIN_TASK_LIST_WIDTH, resolvedColumnWidthTotal);
   const effectiveTaskListWidth = Math.max(requestedTaskListWidth, resolvedColumnWidthTotal);
   const tableHeaderHeight = headerHeight + 1;
-  const updateColumnWidth = useCallback6((columnId, width) => {
+  const updateColumnWidth = useCallback7((columnId, width) => {
     setColumnWidthOverrides((prev) => {
       if (prev[columnId] === width) {
         return prev;
@@ -11047,7 +11261,7 @@ var TaskList = ({
       document.body.style.removeProperty("touch-action");
     };
   }, [resolvedColumns, updateColumnWidth]);
-  const startColumnResize = useCallback6((columnId, event) => {
+  const startColumnResize = useCallback7((columnId, event) => {
     if (resizeStateRef.current) {
       return;
     }
@@ -11074,7 +11288,7 @@ var TaskList = ({
     document.body.style.userSelect = "none";
     document.body.style.touchAction = "none";
   }, [resolvedColumns]);
-  const renderResizeHandle = useCallback6((columnId) => /* @__PURE__ */ jsx18(
+  const renderResizeHandle = useCallback7((columnId) => /* @__PURE__ */ jsx18(
     "button",
     {
       type: "button",
@@ -11431,7 +11645,7 @@ var TaskList = ({
 };
 
 // src/components/ResourceTimelineChart/ResourceTimelineChart.tsx
-import React15, { useCallback as useCallback8, useEffect as useEffect10, useMemo as useMemo11, useRef as useRef10, useState as useState10 } from "react";
+import React15, { useCallback as useCallback9, useEffect as useEffect10, useMemo as useMemo11, useRef as useRef11, useState as useState10 } from "react";
 
 // src/utils/resourceTimelineLayout.ts
 var isInvalidDate = (date) => Number.isNaN(date.getTime());
@@ -11633,7 +11847,7 @@ var layoutResourceTimelineItems = (resources, options) => {
 };
 
 // src/hooks/useResourceItemDrag.ts
-import { useCallback as useCallback7, useEffect as useEffect9, useRef as useRef9, useState as useState9 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect9, useRef as useRef10, useState as useState9 } from "react";
 var RESOURCE_CURSOR_STYLE_ID = "gantt-resource-global-drag-cursor-style";
 function ensureResourceGlobalCursorStyle() {
   if (typeof document === "undefined") return;
@@ -11745,10 +11959,10 @@ var useResourceItemDrag = ({
   weekendPredicate,
   onResourceItemMove
 }) => {
-  const activeDragRef = useRef9(null);
-  const rowsRef = useRef9(rows);
-  const onResourceItemMoveRef = useRef9(onResourceItemMove);
-  const rafRef = useRef9(null);
+  const activeDragRef = useRef10(null);
+  const rowsRef = useRef10(rows);
+  const onResourceItemMoveRef = useRef10(onResourceItemMove);
+  const rafRef = useRef10(null);
   const [preview, setPreview] = useState9(null);
   useEffect9(() => {
     rowsRef.current = rows;
@@ -11756,13 +11970,13 @@ var useResourceItemDrag = ({
   useEffect9(() => {
     onResourceItemMoveRef.current = onResourceItemMove;
   }, [onResourceItemMove]);
-  const clearRaf = useCallback7(() => {
+  const clearRaf = useCallback8(() => {
     if (rafRef.current !== null) {
       cancelAnimationFrame(rafRef.current);
       rafRef.current = null;
     }
   }, []);
-  const cancelDrag2 = useCallback7(() => {
+  const cancelDrag2 = useCallback8(() => {
     clearRaf();
     clearResourceGlobalCursor();
     activeDragRef.current = null;
@@ -11841,7 +12055,7 @@ var useResourceItemDrag = ({
       cancelDrag2();
     };
   }, [cancelDrag2, clearRaf, disableResourceReassignment, gridElementRef]);
-  const startDrag = useCallback7((event, layoutItem) => {
+  const startDrag = useCallback8((event, layoutItem) => {
     if (readonly || layoutItem.item.locked || event.button !== 0) {
       return;
     }
@@ -12106,8 +12320,8 @@ var ResourceHeader = ({
   const [scopeMenuOpen, setScopeMenuOpen] = useState10(false);
   const [editingName, setEditingName] = useState10(false);
   const [nameValue, setNameValue] = useState10(resource.name);
-  const nameInputRef = useRef10(null);
-  const nameConfirmedRef = useRef10(false);
+  const nameInputRef = useRef11(null);
+  const nameConfirmedRef = useRef11(false);
   const visibleCommands = useMemo11(
     () => menuCommands.filter((command) => command.isVisible?.(resource) ?? true),
     [menuCommands, resource]
@@ -12117,7 +12331,7 @@ var ResourceHeader = ({
   const scope = resource.scope ?? "Project";
   const scopeLabel = RESOURCE_SCOPE_LABELS[scope] ?? scope;
   const isInactive = isInactiveResourceStatus(resource.status);
-  const applyResourcePatch = useCallback8((patch) => {
+  const applyResourcePatch = useCallback9((patch) => {
     onResourceChange?.({ ...resource, ...patch });
   }, [onResourceChange, resource]);
   useEffect10(() => {
@@ -12138,7 +12352,7 @@ var ResourceHeader = ({
     }
     command.onSelect(resource);
   };
-  const handleNameDoubleClick = useCallback8((event) => {
+  const handleNameDoubleClick = useCallback9((event) => {
     if (!onResourceChange) {
       return;
     }
@@ -12147,7 +12361,7 @@ var ResourceHeader = ({
     setNameValue(resource.name);
     setEditingName(true);
   }, [onResourceChange, resource.name]);
-  const handleNameSave = useCallback8(() => {
+  const handleNameSave = useCallback9(() => {
     if (nameConfirmedRef.current) {
       nameConfirmedRef.current = false;
       return;
@@ -12158,11 +12372,11 @@ var ResourceHeader = ({
     }
     setEditingName(false);
   }, [applyResourcePatch, nameValue, resource.name]);
-  const handleNameCancel = useCallback8(() => {
+  const handleNameCancel = useCallback9(() => {
     setNameValue(resource.name);
     setEditingName(false);
   }, [resource.name]);
-  const handleNameKeyDown = useCallback8((event) => {
+  const handleNameKeyDown = useCallback9((event) => {
     if (event.key === "Enter") {
       nameConfirmedRef.current = true;
       const nextName = nameValue.trim();
@@ -12367,8 +12581,8 @@ var ResourceHeader = ({
 };
 var NewResourceRow = ({ height, onConfirm, onCancel, columnTemplate }) => {
   const [nameValue, setNameValue] = useState10("");
-  const inputRef = useRef10(null);
-  const confirmedRef = useRef10(false);
+  const inputRef = useRef11(null);
+  const confirmedRef = useRef11(false);
   useEffect10(() => {
     inputRef.current?.focus();
     inputRef.current?.select();
@@ -12454,13 +12668,13 @@ function ResourceTimelineChart({
   resourceTableColumnWidths,
   onResourceTableColumnWidthsChange
 }) {
-  const scrollContainerRef = useRef10(null);
-  const gridRef = useRef10(null);
-  const panStateRef = useRef10(null);
-  const resourceColumnResizeRef = useRef10(null);
-  const conflictNavigationIndexRef = useRef10(/* @__PURE__ */ new Map());
-  const resourceNavigationIndexRef = useRef10(/* @__PURE__ */ new Map());
-  const conflictHighlightTimeoutRef = useRef10(null);
+  const scrollContainerRef = useRef11(null);
+  const gridRef = useRef11(null);
+  const panStateRef = useRef11(null);
+  const resourceColumnResizeRef = useRef11(null);
+  const conflictNavigationIndexRef = useRef11(/* @__PURE__ */ new Map());
+  const resourceNavigationIndexRef = useRef11(/* @__PURE__ */ new Map());
+  const conflictHighlightTimeoutRef = useRef11(null);
   const [isCreatingResource, setIsCreatingResource] = useState10(false);
   const [creatingResourceGroupType, setCreatingResourceGroupType] = useState10(null);
   const [activeConflictItemId, setActiveConflictItemId] = useState10(null);
@@ -12534,7 +12748,7 @@ function ResourceTimelineChart({
   const canAddResource = enableAddResource && Boolean(onAddResource);
   const resourceAddRowHeight = laneHeight + DEFAULT_RESOURCE_ROW_GAP;
   const [collapsedResourceGroups, setCollapsedResourceGroups] = useState10(/* @__PURE__ */ new Set());
-  const updateResourceColumnWidth = useCallback8((columnId, width) => {
+  const updateResourceColumnWidth = useCallback9((columnId, width) => {
     setResourceColumnWidthOverrides((prev) => {
       if (prev[columnId] === width) {
         return prev;
@@ -12573,7 +12787,7 @@ function ResourceTimelineChart({
       document.body.style.removeProperty("user-select");
     };
   }, [updateResourceColumnWidth]);
-  const startResourceColumnResize = useCallback8((columnId, event) => {
+  const startResourceColumnResize = useCallback9((columnId, event) => {
     const width = resolvedResourceColumnWidths[columnId];
     if (typeof width !== "number") {
       return;
@@ -12588,7 +12802,7 @@ function ResourceTimelineChart({
     document.body.style.cursor = "col-resize";
     document.body.style.userSelect = "none";
   }, [resolvedResourceColumnWidths]);
-  const renderResizeHandle = useCallback8((columnId) => /* @__PURE__ */ jsx19(
+  const renderResizeHandle = useCallback9((columnId) => /* @__PURE__ */ jsx19(
     "button",
     {
       type: "button",
@@ -12602,7 +12816,7 @@ function ResourceTimelineChart({
       }
     }
   ), [startResourceColumnResize]);
-  const toggleResourceGroupCollapsed = useCallback8((groupKey) => {
+  const toggleResourceGroupCollapsed = useCallback9((groupKey) => {
     setCollapsedResourceGroups((prev) => {
       const next = new Set(prev);
       if (next.has(groupKey)) {
@@ -12728,7 +12942,7 @@ function ResourceTimelineChart({
   }, [displayLayout.items]);
   const displayTotalHeight = displayLayout.totalHeight + (canAddResource ? resourceAddRowHeight : 0);
   const timelineHeaderHeight = headerHeight + 1;
-  const handleConfirmNewResource = useCallback8((name) => {
+  const handleConfirmNewResource = useCallback9((name) => {
     onAddResource?.({
       id: crypto.randomUUID(),
       name,
@@ -12739,7 +12953,7 @@ function ResourceTimelineChart({
     setIsCreatingResource(false);
     setCreatingResourceGroupType(null);
   }, [creatingResourceGroupType, onAddResource]);
-  const handleStartAddResourceToGroup = useCallback8((type) => {
+  const handleStartAddResourceToGroup = useCallback9((type) => {
     setIsCreatingResource(false);
     setCreatingResourceGroupType(type);
     setCollapsedResourceGroups((prev) => {
@@ -12751,11 +12965,11 @@ function ResourceTimelineChart({
       return next;
     });
   }, []);
-  const handleCancelNewResource = useCallback8(() => {
+  const handleCancelNewResource = useCallback9(() => {
     setIsCreatingResource(false);
     setCreatingResourceGroupType(null);
   }, []);
-  const handleConflictBadgeClick = useCallback8((resourceId) => {
+  const handleConflictBadgeClick = useCallback9((resourceId) => {
     const conflictItems = conflictItemsByResourceId.get(resourceId) ?? [];
     if (conflictItems.length === 0) {
       return;
@@ -12780,7 +12994,7 @@ function ResourceTimelineChart({
       conflictHighlightTimeoutRef.current = null;
     }, 1600);
   }, [conflictItemsByResourceId, dayWidth, laneHeight]);
-  const handleResourceNameClick = useCallback8((resourceId) => {
+  const handleResourceNameClick = useCallback9((resourceId) => {
     const resourceItems = itemsByResourceId.get(resourceId) ?? [];
     if (resourceItems.length === 0) {
       return;
@@ -12825,7 +13039,7 @@ function ResourceTimelineChart({
       container.removeEventListener("scroll", updateShadow);
     };
   }, []);
-  const handlePanStart = useCallback8((event) => {
+  const handlePanStart = useCallback9((event) => {
     if (event.button !== 0) {
       return;
     }
@@ -13312,7 +13526,7 @@ function ResourceTimelineChart({
 }
 
 // src/components/TableMatrix/TableMatrix.tsx
-import { useLayoutEffect, useMemo as useMemo12, useRef as useRef11, useState as useState11 } from "react";
+import { useLayoutEffect, useMemo as useMemo12, useRef as useRef12, useState as useState11 } from "react";
 import { jsx as jsx20, jsxs as jsxs14 } from "react/jsx-runtime";
 var AUTO_COLUMN_MIN_WIDTH = 72;
 var AUTO_COLUMN_MAX_WIDTH = 180;
@@ -13379,7 +13593,7 @@ function TableMatrix({
   filterMode = "highlight",
   visibleRowIndices
 }) {
-  const measureRef = useRef11(null);
+  const measureRef = useRef12(null);
   const [measuredAutoWidths, setMeasuredAutoWidths] = useState11([]);
   const hasAutoWidthColumns = useMemo12(
     () => columns.some((column) => typeof column.width !== "number"),
@@ -13680,7 +13894,7 @@ function TableMatrix({
 }
 
 // src/components/PlanFactMatrix/PlanFactMatrix.tsx
-import React17, { useCallback as useCallback9, useEffect as useEffect11, useMemo as useMemo13, useRef as useRef12, useState as useState12 } from "react";
+import React17, { useCallback as useCallback10, useEffect as useEffect11, useMemo as useMemo13, useRef as useRef13, useState as useState12 } from "react";
 import { jsx as jsx21, jsxs as jsxs15 } from "react/jsx-runtime";
 var DAY_MS6 = 24 * 60 * 60 * 1e3;
 function joinClasses2(...values) {
@@ -13773,7 +13987,7 @@ function PlanFactCellEditor({
   onCancel
 }) {
   const [draft, setDraft] = useState12(startValue ?? (value === void 0 ? "" : String(value)));
-  const inputRef = useRef12(null);
+  const inputRef = useRef13(null);
   useEffect11(() => {
     inputRef.current?.focus();
     if (startValue === void 0) {
@@ -13782,7 +13996,7 @@ function PlanFactCellEditor({
       inputRef.current?.setSelectionRange(startValue.length, startValue.length);
     }
   }, [startValue]);
-  const commit = useCallback9(() => {
+  const commit = useCallback10(() => {
     const parsed = parseNumberInput(draft);
     if (parsed === null) {
       onCancel();
@@ -14132,13 +14346,13 @@ function PlanFactMatrix({
   const [selectedRange, setSelectedRange] = useState12(null);
   const [fillRange, setFillRange] = useState12(null);
   const [overflowTooltip, setOverflowTooltip] = useState12(null);
-  const isSelectingRef = useRef12(false);
-  const isFillDraggingRef = useRef12(false);
-  const didDragSelectRef = useRef12(false);
-  const pendingHoverCellRef = useRef12(null);
-  const hoverFrameRef = useRef12(null);
-  const rootRef = useRef12(null);
-  const bodyRef = useRef12(null);
+  const isSelectingRef = useRef13(false);
+  const isFillDraggingRef = useRef13(false);
+  const didDragSelectRef = useRef13(false);
+  const pendingHoverCellRef = useRef13(null);
+  const hoverFrameRef = useRef13(null);
+  const rootRef = useRef13(null);
+  const bodyRef = useRef13(null);
   const totalWidth = dateRange.length * dayWidth;
   const subrowHeight = rowHeight / 2;
   const renderedRowIndices = useMemo13(
@@ -14187,7 +14401,7 @@ function PlanFactMatrix({
     }
     return rangeByTaskId;
   }, [dateRange.length, dateRangeStartMs, tasks]);
-  const focusCell = useCallback9((cell) => {
+  const focusCell = useCallback10((cell) => {
     window.requestAnimationFrame(() => {
       const selector = [
         `[data-plan-fact-task-id="${escapeAttributeValue(cell.taskId)}"]`,
@@ -14197,7 +14411,7 @@ function PlanFactMatrix({
       bodyRef.current?.querySelector(selector)?.focus();
     });
   }, []);
-  const clearSelection = useCallback9(() => {
+  const clearSelection = useCallback10(() => {
     if (hoverFrameRef.current !== null) {
       window.cancelAnimationFrame(hoverFrameRef.current);
       hoverFrameRef.current = null;
@@ -14212,10 +14426,10 @@ function PlanFactMatrix({
     setFillRange(null);
     setOverflowTooltip(null);
   }, []);
-  const hideOverflowTooltip = useCallback9(() => {
+  const hideOverflowTooltip = useCallback10(() => {
     setOverflowTooltip(null);
   }, []);
-  const flushPendingHoverCell = useCallback9(() => {
+  const flushPendingHoverCell = useCallback10(() => {
     hoverFrameRef.current = null;
     const currentCell = pendingHoverCellRef.current;
     if (!currentCell) return;
@@ -14233,12 +14447,12 @@ function PlanFactMatrix({
     }));
     onTaskSelect?.(currentCell.taskId);
   }, [onTaskSelect, selectedRange]);
-  const queueHoverCellUpdate = useCallback9((cell) => {
+  const queueHoverCellUpdate = useCallback10((cell) => {
     pendingHoverCellRef.current = cell;
     if (hoverFrameRef.current !== null) return;
     hoverFrameRef.current = window.requestAnimationFrame(flushPendingHoverCell);
   }, [flushPendingHoverCell]);
-  const showOverflowTooltip = useCallback9((target, label, force = false) => {
+  const showOverflowTooltip = useCallback10((target, label, force = false) => {
     if (!rootRef.current || !label) return;
     if (!force && target.scrollWidth <= target.clientWidth) {
       setOverflowTooltip(null);
@@ -14252,12 +14466,12 @@ function PlanFactMatrix({
       top: targetRect.top - rootRect.top
     });
   }, []);
-  const selectSingleCell = useCallback9((cell) => {
+  const selectSingleCell = useCallback10((cell) => {
     setActiveCell(cell);
     setSelectedRange({ anchor: cell, focus: cell });
     setFillRange(null);
   }, []);
-  const getRangeBounds = useCallback9((range) => {
+  const getRangeBounds = useCallback10((range) => {
     const anchorTaskIndex = taskIndexById.get(range.anchor.taskId);
     const focusTaskIndex = taskIndexById.get(range.focus.taskId);
     if (anchorTaskIndex === void 0 || focusTaskIndex === void 0) {
@@ -14281,7 +14495,7 @@ function PlanFactMatrix({
     () => renderedRange ? getRangeBounds(renderedRange) : null,
     [getRangeBounds, renderedRange]
   );
-  const getCellFromPosition = useCallback9((subrowIndex, dateIndex) => {
+  const getCellFromPosition = useCallback10((subrowIndex, dateIndex) => {
     const task = tasks[Math.floor(subrowIndex / 2)];
     if (!task) return null;
     return {
@@ -14290,7 +14504,7 @@ function PlanFactMatrix({
       kind: subrowIndex % 2 === 0 ? "plan" : "fact"
     };
   }, [tasks]);
-  const isCellInRange = useCallback9((cell, range) => {
+  const isCellInRange = useCallback10((cell, range) => {
     const bounds = getRangeBounds(range);
     if (!bounds) return false;
     const cellTaskIndex = taskIndexById.get(cell.taskId);
@@ -14300,7 +14514,7 @@ function PlanFactMatrix({
     const cellSubrowIndex = getSubrowIndex(cellTaskIndex, cell.kind);
     return cell.dateIndex >= bounds.fromDateIndex && cell.dateIndex <= bounds.toDateIndex && cellSubrowIndex >= bounds.fromSubrowIndex && cellSubrowIndex <= bounds.toSubrowIndex;
   }, [getRangeBounds, taskIndexById]);
-  const commitCell = useCallback9((task, dateIndex, kind, value) => {
+  const commitCell = useCallback10((task, dateIndex, kind, value) => {
     const dateKey = dateKeys[dateIndex];
     const source = kind === "plan" ? task.planByDate : task.factByDate;
     const nextValues = { ...source ?? {} };
@@ -14322,7 +14536,7 @@ function PlanFactMatrix({
       value
     });
   }, [dateKeys, dateRange, onCellCommit, onTasksChange]);
-  const commitRangeCells = useCallback9((bounds, value, mode) => {
+  const commitRangeCells = useCallback10((bounds, value, mode) => {
     const changedTasksById = /* @__PURE__ */ new Map();
     for (let subrowIndex = bounds.fromSubrowIndex; subrowIndex <= bounds.toSubrowIndex; subrowIndex += 1) {
       const task = tasks[Math.floor(subrowIndex / 2)];
@@ -14369,7 +14583,7 @@ function PlanFactMatrix({
       onTasksChange?.(changedTasks);
     }
   }, [dateKeys, onTasksChange, parentTaskIds, tasks]);
-  const clearSelectedCells = useCallback9(() => {
+  const clearSelectedCells = useCallback10(() => {
     const activeRange = fillRange ?? selectedRange;
     if (!activeRange) {
       if (!activeCell) return;
@@ -14383,7 +14597,7 @@ function PlanFactMatrix({
       commitRangeCells(bounds, void 0, "clear");
     }
   }, [activeCell, commitCell, commitRangeCells, fillRange, getRangeBounds, parentTaskIds, selectedRange, taskById]);
-  const commitSelectedCells = useCallback9((value) => {
+  const commitSelectedCells = useCallback10((value) => {
     const activeRange = fillRange ?? selectedRange;
     if (!activeRange) {
       if (!activeCell) return;
@@ -14397,13 +14611,13 @@ function PlanFactMatrix({
       commitRangeCells(bounds, value, "set");
     }
   }, [activeCell, commitCell, commitRangeCells, fillRange, getRangeBounds, parentTaskIds, selectedRange, taskById]);
-  const getCellValue = useCallback9((cell) => {
+  const getCellValue = useCallback10((cell) => {
     const task = taskById.get(cell.taskId);
     if (!task) return void 0;
     const dateKey = dateKeys[cell.dateIndex];
     return cell.kind === "plan" ? task.planByDate?.[dateKey] : task.factByDate?.[dateKey];
   }, [dateKeys, taskById]);
-  const applyFillRange = useCallback9((nextFillRange) => {
+  const applyFillRange = useCallback10((nextFillRange) => {
     const targetRange = nextFillRange ?? fillRange;
     if (!selectedRange || !targetRange) return;
     const sourceBounds = getRangeBounds(selectedRange);
@@ -14476,7 +14690,7 @@ function PlanFactMatrix({
     selectedRange,
     taskById
   ]);
-  const moveActiveCell = useCallback9((cell, direction) => {
+  const moveActiveCell = useCallback10((cell, direction) => {
     const taskIndex = tasks.findIndex((task) => task.id === cell.taskId);
     if (taskIndex < 0) return;
     let nextCell = { ...cell };
@@ -14508,7 +14722,7 @@ function PlanFactMatrix({
     onTaskSelect?.(nextCell.taskId);
     focusCell(nextCell);
   }, [dateRange.length, focusCell, onTaskSelect, parentTaskIds, tasks]);
-  const extendSelectedRange = useCallback9((cell, direction) => {
+  const extendSelectedRange = useCallback10((cell, direction) => {
     const taskIndex = tasks.findIndex((task) => task.id === cell.taskId);
     if (taskIndex < 0) return;
     let nextCell = { ...cell };
@@ -15303,17 +15517,6 @@ function TaskGanttChartInner(props, ref) {
     onTaskDateChangeModeChange: externalOnTaskDateChangeModeChange,
     printDependencyLabels = false
   } = props;
-  const resolvedActivityDependencies = useMemo14(() => {
-    if (activityDependencies !== void 0) return activityDependencies;
-    return tasks.flatMap((task) => (task.activities ?? []).slice(1).map((successor, index) => ({
-      predecessorTaskId: task.id,
-      predecessorActivityId: task.activities[index].id,
-      successorTaskId: task.id,
-      successorActivityId: successor.id,
-      type: "FS",
-      lag: successor.lag ?? 0
-    })));
-  }, [tasks, activityDependencies]);
   const dayWidth = !isTableMatrixMode ? props.dayWidth ?? 40 : 40;
   const criticalPathMode = !isTableMatrixMode && !isPlanFactMode ? props.criticalPathMode : void 0;
   const onSubtreeScaleResult = !isTableMatrixMode && !isPlanFactMode ? props.onSubtreeScaleResult : void 0;
@@ -15327,17 +15530,17 @@ function TaskGanttChartInner(props, ref) {
   const onMatrixCellClick = isTableMatrixMode ? props.onMatrixCellClick : void 0;
   const matrixDateOverlay = isTableMatrixMode ? props.matrixDateOverlay : void 0;
   const onPlanFactCellCommit = isPlanFactMode ? props.onPlanFactCellCommit : void 0;
-  const containerRef = useRef13(null);
-  const scrollContainerRef = useRef13(null);
-  const scrollContentRef = useRef13(null);
-  const clearSelectedTaskTimeoutRef = useRef13(null);
-  const hasAutoScrolledToTodayRef = useRef13(false);
-  const previewPositionStoreRef = useRef13(null);
-  const activityPreviewStoreRef = useRef13(null);
-  const activityBlockStoreRef = useRef13(null);
-  const activityDragOwnerRef = useRef13(null);
-  const activityActivationStoreRef = useRef13(null);
-  const renderedTaskIdsRef = useRef13(/* @__PURE__ */ new Set());
+  const containerRef = useRef14(null);
+  const scrollContainerRef = useRef14(null);
+  const scrollContentRef = useRef14(null);
+  const clearSelectedTaskTimeoutRef = useRef14(null);
+  const hasAutoScrolledToTodayRef = useRef14(false);
+  const previewPositionStoreRef = useRef14(null);
+  const activityPreviewStoreRef = useRef14(null);
+  const activityBlockStoreRef = useRef14(null);
+  const activityDragOwnerRef = useRef14(null);
+  const activityActivationStoreRef = useRef14(null);
+  const renderedTaskIdsRef = useRef14(/* @__PURE__ */ new Set());
   if (previewPositionStoreRef.current === null) {
     previewPositionStoreRef.current = createTaskPreviewPositionStore();
   }
@@ -15373,10 +15576,10 @@ function TaskGanttChartInner(props, ref) {
   const [planFactDateWindow, setPlanFactDateWindow] = useState13({ start: 0, end: 0 });
   const [selectedChip, setSelectedChip] = useState13(null);
   const [dependencyCreationDrag, setDependencyCreationDrag] = useState13(null);
-  const dependencyCreationRef = useRef13(null);
+  const dependencyCreationRef = useRef14(null);
   const [dependencyCreationError, setDependencyCreationError] = useState13(null);
   const [dependencyLineMenu, setDependencyLineMenu] = useState13(null);
-  const getDependencyPortPoint = useCallback10((element, chartRect) => {
+  const getDependencyPortPoint = useCallback11((element, chartRect) => {
     const rect = element.getBoundingClientRect();
     const side = element.getAttribute("data-port-side");
     return {
@@ -15390,13 +15593,13 @@ function TaskGanttChartInner(props, ref) {
       y: rect.top + rect.height / 2 - chartRect.top
     };
   }, []);
-  const getVisualDependencyType = useCallback10((sourceSide, targetSide) => {
+  const getVisualDependencyType = useCallback11((sourceSide, targetSide) => {
     if (sourceSide === "right" && targetSide === "left") return "FS";
     if (sourceSide === "left" && targetSide === "left") return "SS";
     if (sourceSide === "right" && targetSide === "right") return "FF";
     return "SF";
   }, []);
-  const handleDependencyPortPointerDown = useCallback10((sourceId, sourceSide, event) => {
+  const handleDependencyPortPointerDown = useCallback11((sourceId, sourceSide, event) => {
     if (disableDependencyEditing || event.button !== 0) return;
     const chartElement = event.currentTarget.closest(".gantt-taskArea");
     if (!(chartElement instanceof HTMLElement)) return;
@@ -15514,7 +15717,7 @@ function TaskGanttChartInner(props, ref) {
       document.removeEventListener("keydown", closeOnEscape);
     };
   }, [dependencyLineMenu]);
-  const handleDependencyLineClick = useCallback10((dependency) => {
+  const handleDependencyLineClick = useCallback11((dependency) => {
     setSelectedChip({
       predecessorId: dependency.predecessorId,
       successorId: dependency.successorId,
@@ -15522,10 +15725,10 @@ function TaskGanttChartInner(props, ref) {
     });
     setDependencyLineMenu(dependency);
   }, []);
-  const handleDependencyLineClose = useCallback10(() => {
+  const handleDependencyLineClose = useCallback11(() => {
     setDependencyLineMenu(null);
   }, []);
-  const handleDependencyLineDelete = useCallback10(() => {
+  const handleDependencyLineDelete = useCallback11(() => {
     if (!dependencyLineMenu) return;
     const successor = tasks.find((task) => task.id === dependencyLineMenu.successorId);
     if (!successor) return;
@@ -15582,7 +15785,7 @@ function TaskGanttChartInner(props, ref) {
     () => buildControlledScheduleIdentity(normalizedTasks),
     [normalizedTasks]
   );
-  const previousControlledScheduleIdentityRef = useRef13(null);
+  const previousControlledScheduleIdentityRef = useRef14(null);
   const controlledScheduleChanged = previousControlledScheduleIdentityRef.current !== null && previousControlledScheduleIdentityRef.current !== controlledScheduleIdentity;
   const [previewTasksById, setPreviewTasksById] = useState13(/* @__PURE__ */ new Map());
   const previewNormalizedTasks = useMemo14(() => {
@@ -15831,7 +16034,7 @@ function TaskGanttChartInner(props, ref) {
       window.removeEventListener("resize", scheduleUpdate);
     };
   }, [dateRange.length, dayWidth, isPlanFactMode, showTaskList, taskListWidth, timelineHeaderHeight]);
-  const scrollToToday = useCallback10(() => {
+  const scrollToToday = useCallback11(() => {
     if (isTableMatrixMode) return;
     const container = scrollContainerRef.current;
     if (!container || dateRange.length === 0) return;
@@ -15843,7 +16046,7 @@ function TaskGanttChartInner(props, ref) {
     const scrollLeft = Math.round(todayOffset + dayWidth / 2 - containerWidth * 0.3);
     container.scrollTo({ left: Math.max(0, scrollLeft), behavior: "smooth" });
   }, [dateRange, dayWidth, isTableMatrixMode]);
-  const scrollToTask = useCallback10((taskId) => {
+  const scrollToTask = useCallback11((taskId) => {
     if (isTableMatrixMode) {
       const container2 = scrollContainerRef.current;
       if (!container2) return;
@@ -15870,7 +16073,7 @@ function TaskGanttChartInner(props, ref) {
     const scrollLeft = Math.round(taskOffset - dayWidth * 2);
     container.scrollTo({ left: Math.max(0, scrollLeft), behavior: "smooth" });
   }, [dateRange, dayWidth, effectiveRowHeight, compositeRowLayout, isTableMatrixMode, tasks, visibleTasks]);
-  const scrollToRow = useCallback10((taskId, options = {}) => {
+  const scrollToRow = useCallback11((taskId, options = {}) => {
     const container = scrollContainerRef.current;
     if (!container) return;
     const task = tasks.find((t) => t.id === taskId);
@@ -15932,7 +16135,7 @@ function TaskGanttChartInner(props, ref) {
     activityDragOwner.set(null);
     activityActivationStore.setActiveKey(null);
   }, [previewPositionStore, activityPreviewStore, activityBlockStore, activityDragOwner, activityActivationStore]);
-  const handleTaskChange = useCallback10((updatedTasks, durationEdit) => {
+  const handleTaskChange = useCallback11((updatedTasks, durationEdit) => {
     let updatedTask = updatedTasks[0];
     if (!updatedTask) return;
     const originalTask = normalizedTasks.find((t) => t.id === updatedTask.id);
@@ -16068,7 +16271,7 @@ function TaskGanttChartInner(props, ref) {
       onTasksChange?.(cascadedTasks);
     }
   }, [tasks, normalizedTasks, onTasksChange, onScheduleIntent, disableConstraints, editingTaskId, businessDays, isCustomWeekend, onSubtreeScaleResult]);
-  const handleTaskDurationChange = useCallback10((task, duration) => {
+  const handleTaskDurationChange = useCallback11((task, duration) => {
     const updatedTask = {
       ...task,
       endDate: task.type === "milestone" ? task.startDate : buildTaskRangeFromStart(
@@ -16080,7 +16283,7 @@ function TaskGanttChartInner(props, ref) {
     };
     handleTaskChange([updatedTask], { duration, anchor: "start" });
   }, [businessDays, handleTaskChange, isCustomWeekend]);
-  const handleDelete = useCallback10((taskId) => {
+  const handleDelete = useCallback11((taskId) => {
     const toDelete = /* @__PURE__ */ new Set([taskId]);
     function collectDescendants(parentId) {
       const children = getChildren(parentId, tasks);
@@ -16105,10 +16308,10 @@ function TaskGanttChartInner(props, ref) {
     }
     toDelete.forEach((id) => onDelete?.(id));
   }, [tasks, onTasksChange, onDelete]);
-  const handleInsertAfter = useCallback10((taskId, newTask) => {
+  const handleInsertAfter = useCallback11((taskId, newTask) => {
     onInsertAfter?.(taskId, newTask);
   }, [onInsertAfter]);
-  const handleReorder = useCallback10((reorderedTasks, movedTaskId, inferredParentId) => {
+  const handleReorder = useCallback11((reorderedTasks, movedTaskId, inferredParentId) => {
     let updated = reorderedTasks;
     if (movedTaskId) {
       updated = updated.map((t) => {
@@ -16140,7 +16343,7 @@ function TaskGanttChartInner(props, ref) {
     }
     return map;
   }, [cascadeOverrides, controlledScheduleChanged, draggedTaskOverride]);
-  const handleCascadeProgress = useCallback10((overrides, previewTasks = []) => {
+  const handleCascadeProgress = useCallback11((overrides, previewTasks = []) => {
     previewPositionStore.setPositions(overrides);
     const renderedTaskIds = renderedTaskIdsRef.current;
     const renderedOverrides = /* @__PURE__ */ new Map();
@@ -16220,7 +16423,7 @@ function TaskGanttChartInner(props, ref) {
       }
     }
     return Array.from(indices).sort((left, right) => left - right);
-  }, [compositeRowLayout, forceFullRenderForPrint, forcedRenderedTaskIds, scrollViewport, visibleTaskIndexMap, visibleTasks.length]);
+  }, [compositeRowLayout, forceFullRenderForPrint, forcedRenderedTaskIds, scrollViewport.scrollTop, scrollViewport.viewportHeight, visibleTaskIndexMap, visibleTasks.length]);
   const visiblePlanFactDateIndices = useMemo14(() => {
     if (forceFullRenderForPrint) {
       return void 0;
@@ -16249,22 +16452,22 @@ function TaskGanttChartInner(props, ref) {
     () => new Set(renderedChartTasks.map(({ task }) => task.id)),
     [renderedChartTasks]
   );
-  const handleCascade = useCallback10((cascadedTasks) => {
+  const handleCascade = useCallback11((cascadedTasks) => {
     if (!onScheduleIntent) {
       onTasksChange?.(cascadedTasks);
     }
   }, [onScheduleIntent, onTasksChange]);
-  const handleTaskSelect = useCallback10((taskId) => {
+  const handleTaskSelect = useCallback11((taskId) => {
     setSelectedTaskId(taskId);
   }, []);
-  const hoveredRowElementsRef = useRef13([]);
-  const clearHoveredRows = useCallback10(() => {
+  const hoveredRowElementsRef = useRef14([]);
+  const clearHoveredRows = useCallback11(() => {
     for (const element of hoveredRowElementsRef.current) {
       element.classList.remove("gantt-tl-row-hovered", "gantt-tr-row-hovered", "gantt-mx-row-hovered", "gantt-pf-row-hovered");
     }
     hoveredRowElementsRef.current = [];
   }, []);
-  const applyHoveredRows = useCallback10((taskId) => {
+  const applyHoveredRows = useCallback11((taskId) => {
     const root = scrollContentRef.current;
     if (!root) return;
     clearHoveredRows();
@@ -16287,7 +16490,7 @@ function TaskGanttChartInner(props, ref) {
     }
     hoveredRowElementsRef.current = nextHoveredRows;
   }, [clearHoveredRows]);
-  const handleSharedRowHover = useCallback10((event) => {
+  const handleSharedRowHover = useCallback11((event) => {
     const target = event.target;
     const row = target.closest("[data-gantt-task-row-id]");
     const taskId = row?.dataset.ganttTaskRowId;
@@ -16317,7 +16520,7 @@ function TaskGanttChartInner(props, ref) {
       return next;
     });
   });
-  const lastCompositeBarToggleRef = useRef13(null);
+  const lastCompositeBarToggleRef = useRef14(null);
   const handleCompositeBarToggle = (taskId, source) => {
     const now = Date.now();
     if (source === "click" && lastCompositeBarToggleRef.current?.source === "release" && lastCompositeBarToggleRef.current.id === taskId && now - lastCompositeBarToggleRef.current.time < 150) return;
@@ -16328,17 +16531,17 @@ function TaskGanttChartInner(props, ref) {
     const taskIds = new Set(normalizedTasks.map((task) => task.id));
     return new Set(normalizedTasks.map((task) => task.parentId).filter((parentId) => Boolean(parentId && taskIds.has(parentId))));
   }, [normalizedTasks]);
-  const handleCollapseAll = useCallback10(() => {
+  const handleCollapseAll = useCallback11(() => {
     if (externalCollapsedParentIds) return;
     setInternalCollapsedParentIds(allParentIds);
     setExpandedCompositeIds(/* @__PURE__ */ new Set());
   }, [allParentIds, externalCollapsedParentIds]);
-  const handleExpandAll = useCallback10(() => {
+  const handleExpandAll = useCallback11(() => {
     if (externalCollapsedParentIds) return;
     setInternalCollapsedParentIds(/* @__PURE__ */ new Set());
     setExpandedCompositeIds(new Set(normalizedTasks.filter((task) => task.composite).map((task) => task.id)));
   }, [externalCollapsedParentIds, normalizedTasks]);
-  const exportToPdf = useCallback10(async (options) => {
+  const exportToPdf = useCallback11(async (options) => {
     const sourceContainer = containerRef.current;
     if (!sourceContainer || typeof window === "undefined" || typeof document === "undefined") {
       return;
@@ -16411,7 +16614,7 @@ function TaskGanttChartInner(props, ref) {
     }
     return depth;
   }
-  const handlePromoteTask = useCallback10((taskId) => {
+  const handlePromoteTask = useCallback11((taskId) => {
     if (onPromoteTask) {
       onPromoteTask(taskId);
       return;
@@ -16443,7 +16646,7 @@ function TaskGanttChartInner(props, ref) {
     ]);
     onTasksChange?.(reorderedTasks);
   }, [tasks, onTasksChange, onPromoteTask]);
-  const handleDemoteTask = useCallback10((taskId, newParentId) => {
+  const handleDemoteTask = useCallback11((taskId, newParentId) => {
     if (onDemoteTask) {
       onDemoteTask(taskId, newParentId);
       return;
@@ -16484,7 +16687,7 @@ function TaskGanttChartInner(props, ref) {
     };
     onTasksChange?.([updatedDemotedTask]);
   }, [tasks, onTasksChange, onDemoteTask]);
-  const handleUngroupTask = useCallback10((taskId) => {
+  const handleUngroupTask = useCallback11((taskId) => {
     if (onUngroupTask) {
       onUngroupTask(taskId);
       return;
@@ -16509,8 +16712,8 @@ function TaskGanttChartInner(props, ref) {
       onTasksChange?.(changedTasks);
     }
   }, [tasks, onTasksChange, onUngroupTask]);
-  const panStateRef = useRef13(null);
-  const handlePanStart = useCallback10((e) => {
+  const panStateRef = useRef14(null);
+  const handlePanStart = useCallback11((e) => {
     if (e.button !== 0) return;
     const target = e.target;
     if (!target.closest(".gantt-tr-activityBar")) {
@@ -16534,6 +16737,7 @@ function TaskGanttChartInner(props, ref) {
     if (document.activeElement instanceof HTMLElement) {
       document.activeElement.blur();
     }
+    container.setAttribute("data-panning", "true");
     container.style.cursor = "grabbing";
     e.preventDefault();
   }, [activityActivationStore]);
@@ -16571,7 +16775,10 @@ function TaskGanttChartInner(props, ref) {
       }
       panStateRef.current = null;
       const container = scrollContainerRef.current;
-      if (container) container.style.cursor = "";
+      if (container) {
+        container.removeAttribute("data-panning");
+        container.style.cursor = "";
+      }
     };
     window.addEventListener("mousemove", handlePanMove);
     window.addEventListener("mouseup", handlePanEnd);
@@ -16790,7 +16997,7 @@ function TaskGanttChartInner(props, ref) {
                                 onHoverEnd: () => setActiveTimelineTooltip(null)
                               }
                             ),
-                            showActivityLinks && resolvedActivityDependencies.length > 0 && /* @__PURE__ */ jsx22(ActivityDependencyLines, { tasks: visibleTasks, renderedTaskIds: renderedTaskIdsRef.current, dependencies: resolvedActivityDependencies, highlight: activityDependencyHighlight, monthStart, dayWidth, rowHeight: effectiveRowHeight, gridWidth: renderGridWidth, totalHeight: totalGridHeight, rowIndexByTaskId: visibleTaskIndexMap, rowTops: compositeRowLayout.tops, rowHeights: compositeRowLayout.heights, showLag: showActivityLag, previewStore: activityPreviewStore, horizontalWindow }),
+                            showActivityLinks && activityDependencies !== void 0 && /* @__PURE__ */ jsx22(ActivityDependencyLines, { tasks: previewVisibleTasks, renderedTaskIds: renderedTaskIdsRef.current, dependencies: activityDependencies, highlight: activityDependencyHighlight, monthStart, dayWidth, rowHeight: effectiveRowHeight, gridWidth: renderGridWidth, totalHeight: totalGridHeight, rowIndexByTaskId: visibleTaskIndexMap, rowTops: compositeRowLayout.tops, rowHeights: compositeRowLayout.heights, showLag: showActivityLag, previewStore: activityPreviewStore, horizontalWindow }),
                             /* @__PURE__ */ jsx22(
                               DependencyLines_default,
                               {
@@ -16933,10 +17140,10 @@ function TaskGanttChartInner(props, ref) {
                                     activityActivationStore,
                                     activityClickToDrag,
                                     activityActivationMode,
-                                    showActivityLinks: false,
+                                    showActivityLinks: showActivityLinks && activityDependencies === void 0,
                                     showActivityLag,
                                     activityTooltip,
-                                    horizontalWindow,
+                                    horizontalWindow: forceFullRenderForPrint ? void 0 : horizontalWindow,
                                     onCascadeProgress: handleCascadeProgress,
                                     onCascade: handleCascade,
                                     onScheduleIntent,