gantt-lib 0.64.1 → 0.71.0

package/dist/index.mjs

@@ -499,6 +499,12 @@ init_dateMath();
 
 // src/core/scheduling/dependencies.ts
 init_dateMath();
+function normalizePredecessorDates(predecessor, parseDateFn) {
+  const predStart = parseDateFn(predecessor.startDate);
+  const isMilestone = predecessor.type === "milestone";
+  const predEnd = isMilestone ? new Date(predStart.getTime() - DAY_MS) : parseDateFn(predecessor.endDate);
+  return { predStart, predEnd };
+}
 function getDependencyLag(dep) {
   return Number.isFinite(dep.lag) ? dep.lag : 0;
 }
@@ -774,8 +780,7 @@ function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks,
     if (!predecessor) {
       continue;
     }
-    const predecessorStart = parseDateOnly(predecessor.startDate);
-    const predecessorEnd = parseDateOnly(predecessor.endDate);
+    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
     const predecessorDuration = getTaskDuration(
       predecessorStart,
       predecessorEnd,
@@ -811,8 +816,10 @@ function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, busin
     if (!predecessor) {
       return { ...dep, lag: getDependencyLag(dep) };
     }
-    const predecessorStart = new Date(predecessor.startDate);
-    const predecessorEnd = new Date(predecessor.endDate);
+    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(
+      predecessor,
+      (d) => new Date(d instanceof Date ? d.getTime() : `${String(d).split("T")[0]}T00:00:00.000Z`)
+    );
     const nextLag = computeLagFromDates(
       dep.type,
       predecessorStart,
@@ -827,6 +834,12 @@ function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, busin
 }
 
 // src/core/scheduling/cascade.ts
+function parseCascadeDateInput(date) {
+  if (date instanceof Date) {
+    return normalizeUTCDate(date);
+  }
+  return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
+}
 function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
   const successorMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
@@ -905,7 +918,21 @@ function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascad
         const origStart = new Date(orig.startDate);
         const origEnd = new Date(orig.endDate);
         const duration = getTaskDuration(origStart, origEnd);
-        const constraintDate = calculateSuccessorDate(predStart, predEnd, dep.type, getDependencyLag(dep));
+        const currentTask = taskById.get(currentId);
+        const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
+          {
+            startDate: predStart,
+            endDate: predEnd,
+            type: currentTask.type
+          },
+          parseCascadeDateInput
+        );
+        const constraintDate = calculateSuccessorDate(
+          normalizedPredStart,
+          normalizedPredEnd,
+          dep.type,
+          getDependencyLag(dep)
+        );
         let newSuccStart;
         let newSuccEnd;
         if (dep.type === "FS" || dep.type === "SS") {
@@ -1060,9 +1087,17 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
       if (!dep) continue;
       const origStart = new Date(task.startDate);
       const origEnd = new Date(task.endDate);
+      const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
+        {
+          startDate: currStart,
+          endDate: currEnd,
+          type: currentOriginal.type
+        },
+        parseCascadeDateInput
+      );
       const constraintDate = calculateSuccessorDate(
-        currStart,
-        currEnd,
+        normalizedPredStart,
+        normalizedPredEnd,
         dep.type,
         getDependencyLag(dep),
         businessDays,
@@ -1279,8 +1314,7 @@ function recalculateTaskFromDependencies(taskId, snapshot, options) {
   for (const dep of task.dependencies) {
     const predecessor = snapshot.find((t) => t.id === dep.taskId);
     if (!predecessor) continue;
-    const predStart = parseDateOnly(predecessor.startDate);
-    const predEnd = parseDateOnly(predecessor.endDate);
+    const { predStart, predEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
     const constraintDate = calculateSuccessorDate(
       predStart,
       predEnd,
@@ -1396,8 +1430,7 @@ function recalculateProjectSchedule(snapshot, options) {
         if (!predecessor) {
           continue;
         }
-        const predecessorStart = parseDateOnly(predecessor.startDate);
-        const predecessorEnd = parseDateOnly(predecessor.endDate);
+        const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
         const constraintDate = calculateSuccessorDate(
           predecessorStart,
           predecessorEnd,
@@ -1816,6 +1849,45 @@ var calculateTaskBar = (taskStartDate, taskEndDate, monthStart, dayWidth) => {
   const width = Math.round((duration + 1) * dayWidth);
   return { left, width };
 };
+var calculateMilestoneGeometry = (taskDate, monthStart, dayWidth, size = 14) => {
+  const { left, width } = calculateTaskBar(taskDate, taskDate, monthStart, dayWidth);
+  const centerX = Math.round(left + width / 2);
+  const halfSize = Math.round(size / 2);
+  return {
+    centerX,
+    left: centerX - halfSize,
+    right: centerX + halfSize,
+    size
+  };
+};
+var calculateMilestoneConnectionBounds = (dayLeft, dayWidth, size = 14) => {
+  const halfDiagonal = Math.round(size / Math.SQRT2);
+  const visualNudge = 2;
+  return {
+    left: dayLeft + halfDiagonal + visualNudge,
+    right: dayLeft + dayWidth - halfDiagonal - visualNudge
+  };
+};
+var resolveTaskHorizontalGeometry = (task, monthStart, dayWidth, override) => {
+  const startDate = new Date(task.startDate);
+  const endDate = new Date(task.endDate);
+  if (task.type === "milestone") {
+    const size = 14;
+    if (override) {
+      return calculateMilestoneConnectionBounds(override.left, dayWidth, size);
+    }
+    const bar2 = calculateTaskBar(startDate, startDate, monthStart, dayWidth);
+    return calculateMilestoneConnectionBounds(bar2.left, dayWidth, size);
+  }
+  if (override) {
+    return {
+      left: override.left,
+      right: override.left + override.width
+    };
+  }
+  const bar = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
+  return { left: bar.left, right: bar.left + bar.width };
+};
 var pixelsToDate = (pixels, monthStart, dayWidth) => {
   const days = Math.round(pixels / dayWidth);
   return new Date(Date.UTC(
@@ -1919,6 +1991,9 @@ var calculateDependencyPath = (from, to, arrivesFromRight) => {
   if (fy === ty) {
     return `M ${fx} ${fy} H ${tx}`;
   }
+  if (fx === tx) {
+    return `M ${fx} ${fy} V ${ty}`;
+  }
   const C = 2;
   const goingDown = ty > fy;
   const dirY = goingDown ? 1 : -1;
@@ -2026,6 +2101,37 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
   return actualProgress < expectedProgress;
 };
 
+// src/utils/taskType.ts
+init_dateUtils();
+var TASK_TYPE_DEFAULT = "task";
+function getTaskType(task) {
+  return task.type ?? TASK_TYPE_DEFAULT;
+}
+function isMilestoneTask(task) {
+  return getTaskType(task) === "milestone";
+}
+function normalizeMilestoneStartDate(startDateInput) {
+  const parsedStartDate = parseUTCDate(startDateInput);
+  if (startDateInput instanceof Date) {
+    return new Date(Date.UTC(
+      parsedStartDate.getUTCFullYear(),
+      parsedStartDate.getUTCMonth(),
+      parsedStartDate.getUTCDate()
+    ));
+  }
+  return parsedStartDate.toISOString().split("T")[0];
+}
+function normalizeTaskDatesForType(task) {
+  if (!isMilestoneTask(task)) {
+    return task;
+  }
+  const startDate = normalizeMilestoneStartDate(task.startDate);
+  return {
+    ...task,
+    endDate: startDate
+  };
+}
+
 // src/hooks/useTaskDrag.ts
 import { useEffect, useRef, useState, useCallback } from "react";
 
@@ -2044,6 +2150,17 @@ function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, tas
     monthStart.getUTCMonth(),
     monthStart.getUTCDate() + rawEndOffset
   ));
+  const isMilestone = task.type === "milestone";
+  if (isMilestone) {
+    const anchorDate = mode === "resize-right" ? rawEndDate : rawStartDate;
+    if (businessDays && weekendPredicate) {
+      const originalAnchor = mode === "resize-right" ? new Date(task.endDate) : new Date(task.startDate);
+      const snapDirection2 = anchorDate.getTime() >= originalAnchor.getTime() ? 1 : -1;
+      const alignedDate = alignToWorkingDay(anchorDate, snapDirection2, weekendPredicate);
+      return { start: alignedDate, end: alignedDate };
+    }
+    return { start: anchorDate, end: anchorDate };
+  }
   if (!(businessDays && weekendPredicate)) {
     return { start: rawStartDate, end: rawEndDate };
   }
@@ -2134,8 +2251,10 @@ function handleGlobalMouseMove(e) {
     const activeDrag = globalActiveDrag;
     const { startX, initialLeft, initialWidth, mode, dayWidth, onProgress, allTasks } = activeDrag;
     const deltaX = e.clientX - startX;
+    const draggedTask = allTasks.find((t) => t.id === activeDrag.taskId);
+    const effectiveWidth = draggedTask && isMilestoneTask(draggedTask) ? dayWidth : initialWidth;
     let newLeft = initialLeft;
-    let newWidth = initialWidth;
+    let newWidth = effectiveWidth;
     switch (mode) {
       case "move":
         newLeft = snapToGrid(initialLeft + deltaX, dayWidth);
@@ -2151,7 +2270,6 @@ function handleGlobalMouseMove(e) {
         newWidth = Math.max(dayWidth, snappedWidth);
         break;
     }
-    const draggedTask = allTasks.find((t) => t.id === activeDrag.taskId);
     if (activeDrag.businessDays && activeDrag.weekendPredicate && draggedTask) {
       const previewRange = clampDateRangeForIncomingFS(
         draggedTask,
@@ -2193,6 +2311,9 @@ function handleGlobalMouseMove(e) {
       newLeft = Math.round(alignedStartDay * dayWidth);
       newWidth = Math.round((alignedEndDay - alignedStartDay + 1) * dayWidth);
     }
+    if (draggedTask && isMilestoneTask(draggedTask)) {
+      newWidth = dayWidth;
+    }
     if (!activeDrag.disableConstraints && activeDrag.onCascadeProgress) {
       const { dayWidth: dayWidth2, monthStart: mStart, taskId: dragId } = activeDrag;
       const originalDraggedTask = draggedTask ?? allTasks.find((t) => t.id === dragId);
@@ -2229,7 +2350,8 @@ function handleGlobalMouseMove(e) {
         };
       })();
       const previewStartDate = previewRange.start;
-      const previewEndDate = previewRange.end;
+      const isMilestone = originalDraggedTask ? isMilestoneTask(originalDraggedTask) : false;
+      const previewEndDate = isMilestone ? previewRange.start : previewRange.end;
       const movedTaskData = originalDraggedTask ?? { id: dragId, name: "", startDate: "", endDate: "" };
       const cascadeResult = universalCascade(
         { ...movedTaskData, startDate: previewStartDate.toISOString(), endDate: previewEndDate.toISOString() },
@@ -2319,6 +2441,9 @@ var useTaskDrag = (options) => {
     businessDays = true,
     weekendPredicate
   } = options;
+  const rawHookTask = allTasks.find((t) => t.id === taskId);
+  const hookTask = rawHookTask ? normalizeTaskDatesForType(rawHookTask) : void 0;
+  const hookTaskIsMilestone = hookTask ? isMilestoneTask(hookTask) : false;
   const isOwnerRef = useRef(false);
   const effectiveLocked = locked || disableTaskDrag;
   const [isDragging, setIsDragging] = useState(false);
@@ -2340,11 +2465,11 @@ var useTaskDrag = (options) => {
       return Math.round((ms1 - ms2) / (1e3 * 60 * 60 * 24));
     };
     const startOffset = getUTCDayDifference2(initialStartDate, monthStart);
-    const duration = getUTCDayDifference2(initialEndDate, initialStartDate);
+    const duration = hookTaskIsMilestone ? 0 : getUTCDayDifference2(initialEndDate, initialStartDate);
     const left = Math.round(startOffset * dayWidth);
     const width = Math.round((duration + 1) * dayWidth);
     return { left, width };
-  }, [initialStartDate, initialEndDate, monthStart, dayWidth]);
+  }, [initialStartDate, initialEndDate, monthStart, dayWidth, hookTaskIsMilestone]);
   useEffect(() => {
     if (isOwnerRef.current && globalActiveDrag) return;
     const { left, width } = getInitialPosition();
@@ -2379,7 +2504,8 @@ var useTaskDrag = (options) => {
   const handleComplete = useCallback((finalLeft, finalWidth, finalMode) => {
     const wasOwner = isOwnerRef.current;
     isOwnerRef.current = false;
-    const currentTask = allTasks.find((t) => t.id === taskId);
+    const currentTaskRaw = allTasks.find((t) => t.id === taskId);
+    const currentTask = currentTaskRaw ? normalizeTaskDatesForType(currentTaskRaw) : void 0;
     const finalRange = currentTask ? clampDateRangeForIncomingFS(
       currentTask,
       resolveDateRangeFromPixels(
@@ -2413,7 +2539,7 @@ var useTaskDrag = (options) => {
       };
     })();
     const newStartDate = finalRange.start;
-    const newEndDate = finalRange.end;
+    const newEndDate = currentTask && isMilestoneTask(currentTask) ? finalRange.start : finalRange.end;
     setIsDragging(false);
     setDragMode(null);
     if (onDragStateChange) {
@@ -2425,6 +2551,23 @@ var useTaskDrag = (options) => {
       });
     }
     if (wasOwner) {
+      const startUnchanged = newStartDate.getTime() === Date.UTC(
+        initialStartDate.getUTCFullYear(),
+        initialStartDate.getUTCMonth(),
+        initialStartDate.getUTCDate()
+      );
+      const baselineEndDate = hookTaskIsMilestone ? initialStartDate : initialEndDate;
+      const endUnchanged = newEndDate.getTime() === Date.UTC(
+        baselineEndDate.getUTCFullYear(),
+        baselineEndDate.getUTCMonth(),
+        baselineEndDate.getUTCDate()
+      );
+      if (startUnchanged && endUnchanged) {
+        const { left, width } = getInitialPosition();
+        setCurrentLeft(left);
+        setCurrentWidth(width);
+        return;
+      }
       if (!disableConstraints && onCascade && allTasks.length > 0) {
         const draggedTaskData = currentTask;
         const movedTask = {
@@ -2462,7 +2605,8 @@ var useTaskDrag = (options) => {
     businessDays,
     weekendPredicate,
     initialStartDate,
-    initialEndDate
+    initialEndDate,
+    hookTaskIsMilestone
   ]);
   const handleCancel = useCallback(() => {
     isOwnerRef.current = false;
@@ -2505,6 +2649,9 @@ var useTaskDrag = (options) => {
       if (currentTask2 && isTaskParent(taskId, allTasks)) {
         mode = "move";
       }
+      if (currentTask2 && isMilestoneTask(currentTask2)) {
+        mode = "move";
+      }
     }
     if (!mode) {
       return;
@@ -2590,14 +2737,16 @@ var useTaskDrag = (options) => {
 // src/components/TaskRow/TaskRow.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var arePropsEqual = (prevProps, nextProps) => {
-  return prevProps.task.id === nextProps.task.id && prevProps.task.name === nextProps.task.name && prevProps.task.startDate === nextProps.task.startDate && prevProps.task.endDate === nextProps.task.endDate && prevProps.task.color === nextProps.task.color && prevProps.task.progress === nextProps.task.progress && prevProps.task.accepted === nextProps.task.accepted && prevProps.monthStart.getTime() === nextProps.monthStart.getTime() && prevProps.dayWidth === nextProps.dayWidth && prevProps.rowHeight === nextProps.rowHeight && prevProps.overridePosition?.left === nextProps.overridePosition?.left && prevProps.overridePosition?.width === nextProps.overridePosition?.width && prevProps.allTasks === nextProps.allTasks && prevProps.disableConstraints === nextProps.disableConstraints && prevProps.task.locked === nextProps.task.locked && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag;
+  return prevProps.task.id === nextProps.task.id && prevProps.task.name === nextProps.task.name && prevProps.task.startDate === nextProps.task.startDate && prevProps.task.endDate === nextProps.task.endDate && prevProps.task.type === nextProps.task.type && prevProps.task.color === nextProps.task.color && prevProps.task.progress === nextProps.task.progress && prevProps.task.accepted === nextProps.task.accepted && prevProps.monthStart.getTime() === nextProps.monthStart.getTime() && prevProps.dayWidth === nextProps.dayWidth && prevProps.rowHeight === nextProps.rowHeight && prevProps.overridePosition?.left === nextProps.overridePosition?.left && prevProps.overridePosition?.width === nextProps.overridePosition?.width && prevProps.allTasks === nextProps.allTasks && prevProps.disableConstraints === nextProps.disableConstraints && prevProps.task.locked === nextProps.task.locked && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag;
 };
 var TaskRow = React2.memo(
   ({ task, monthStart, dayWidth, rowHeight, onTasksChange, onDragStateChange, rowIndex, allTasks, enableAutoSchedule, disableConstraints, overridePosition, onCascadeProgress, onCascade, divider, highlightExpiredTasks, isFilterMatch = false, businessDays, customDays, isWeekend: isWeekend3, disableTaskDrag = false }) => {
     const defaultParentBarColor = "#782FC4";
     const { divider: taskDivider } = task;
-    const taskStartDate = useMemo2(() => parseUTCDate(task.startDate), [task.startDate]);
-    const taskEndDate = useMemo2(() => parseUTCDate(task.endDate), [task.endDate]);
+    const normalizedTask = useMemo2(() => normalizeTaskDatesForType(task), [task]);
+    const milestone = useMemo2(() => isMilestoneTask(normalizedTask), [normalizedTask]);
+    const taskStartDate = useMemo2(() => parseUTCDate(normalizedTask.startDate), [normalizedTask.startDate]);
+    const taskEndDate = useMemo2(() => parseUTCDate(normalizedTask.endDate), [normalizedTask.endDate]);
     const isParent = useMemo2(() => {
       return allTasks ? isTaskParent(task.id, allTasks) : false;
     }, [allTasks, task.id]);
@@ -2606,12 +2755,16 @@ var TaskRow = React2.memo(
     }, [allTasks, task.id]);
     const isExpired = useMemo2(() => {
       if (!highlightExpiredTasks) return false;
-      return isTaskExpired(task);
-    }, [task.startDate, task.endDate, task.progress, highlightExpiredTasks]);
+      return isTaskExpired(normalizedTask);
+    }, [normalizedTask.startDate, normalizedTask.endDate, normalizedTask.progress, highlightExpiredTasks]);
     const { left, width } = useMemo2(
       () => calculateTaskBar(taskStartDate, taskEndDate, monthStart, dayWidth),
       [taskStartDate, taskEndDate, monthStart, dayWidth]
     );
+    const milestoneGeometry = useMemo2(
+      () => calculateMilestoneGeometry(taskStartDate, monthStart, dayWidth),
+      [taskStartDate, monthStart, dayWidth]
+    );
     const barColor = isExpired ? "var(--gantt-expired-color)" : task.color || "var(--gantt-task-bar-default-color)";
     const progressWidth = useMemo2(() => {
       if (task.progress === void 0 || task.progress <= 0) return 0;
@@ -2650,7 +2803,7 @@ var TaskRow = React2.memo(
     }, [defaultParentBarColor, isExpired, isParent, progressWidth, barColor, progressColor, task.color]);
     const handleDragEnd = (result) => {
       const updatedTask = {
-        ...task,
+        ...normalizedTask,
         startDate: result.startDate.toISOString(),
         endDate: result.endDate.toISOString(),
         ...result.updatedDependencies !== void 0 && { dependencies: result.updatedDependencies }
@@ -2689,8 +2842,20 @@ var TaskRow = React2.memo(
     });
     const displayLeft = overridePosition?.left ?? (isDragging ? currentLeft : left);
     const displayWidth = overridePosition?.width ?? (isDragging ? currentWidth : width);
+    const displayMilestoneGeometry = useMemo2(() => {
+      const centerX = Math.round(displayLeft + dayWidth / 2);
+      const halfSize = Math.round(milestoneGeometry.size / 2);
+      return {
+        centerX,
+        left: centerX - halfSize,
+        right: centerX + halfSize,
+        size: milestoneGeometry.size
+      };
+    }, [displayLeft, dayWidth, milestoneGeometry.size]);
+    const visualLeft = milestone ? displayMilestoneGeometry.left : displayLeft;
+    const visualWidth = milestone ? displayMilestoneGeometry.size : displayWidth;
     const currentStartDate = isDragging ? pixelsToDate(displayLeft, monthStart, dayWidth) : taskStartDate;
-    const currentEndDate = isDragging ? pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
+    const currentEndDate = isDragging ? milestone ? pixelsToDate(displayLeft, monthStart, dayWidth) : pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
     const dateRangeLabel = formatDateRangeLabel(currentStartDate, currentEndDate);
     const durationDays = businessDays ? getBusinessDaysCount(currentStartDate, currentEndDate, weekendPredicate) : Math.round(
       (currentEndDate.getTime() - currentStartDate.getTime()) / (1e3 * 60 * 60 * 24)
@@ -2705,9 +2870,9 @@ var TaskRow = React2.memo(
       return `${count} \u0437\u0430\u0434\u0430\u0447`;
     };
     const estimatedTextWidth = isParent ? 120 : durationDays >= 10 ? 76 : 62;
-    const showProgressInside = progressWidth > 0 && displayWidth > estimatedTextWidth;
+    const showProgressInside = !milestone && progressWidth > 0 && displayWidth > estimatedTextWidth;
     const MIN_DURATION_WIDTH = isParent ? 80 : 50;
-    const showDurationInside = durationDays >= 2 && displayWidth > MIN_DURATION_WIDTH;
+    const showDurationInside = !milestone && durationDays >= 2 && displayWidth > MIN_DURATION_WIDTH;
     return /* @__PURE__ */ jsxs2(
       "div",
       {
@@ -2721,18 +2886,24 @@ var TaskRow = React2.memo(
               "div",
               {
                 "data-taskbar": true,
-                className: `gantt-tr-taskBar ${isDragging ? "gantt-tr-dragging" : ""} ${task.locked ? "gantt-tr-locked" : ""} ${isParent ? "gantt-tr-parentBar" : ""}`,
+                className: `gantt-tr-taskBar ${isDragging ? "gantt-tr-dragging" : ""} ${task.locked ? "gantt-tr-locked" : ""} ${isParent ? "gantt-tr-parentBar" : ""} ${milestone ? "gantt-tr-milestone" : ""}`,
                 style: {
-                  left: `${displayLeft}px`,
-                  width: `${displayWidth}px`,
+                  left: `${visualLeft}px`,
                   ...barStyle,
-                  height: isParent ? "var(--gantt-parent-bar-height, 14px)" : "var(--gantt-task-bar-height)",
+                  ...milestone ? {
+                    height: `${displayMilestoneGeometry.size}px`,
+                    width: `${displayMilestoneGeometry.size}px`,
+                    padding: 0
+                  } : {
+                    width: `${visualWidth}px`,
+                    height: isParent ? "var(--gantt-parent-bar-height, 14px)" : "var(--gantt-task-bar-height)"
+                  },
                   cursor: dragHandleProps.style.cursor,
                   userSelect: dragHandleProps.style.userSelect
                 },
                 onMouseDown: dragHandleProps.onMouseDown,
                 children: [
-                  progressWidth > 0 && progressWidth < 100 && /* @__PURE__ */ jsx2(
+                  !milestone && progressWidth > 0 && progressWidth < 100 && /* @__PURE__ */ jsx2(
                     "div",
                     {
                       className: "gantt-tr-progressBar",
@@ -2745,13 +2916,13 @@ var TaskRow = React2.memo(
                       }
                     }
                   ),
-                  !isParent && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
+                  !isParent && !milestone && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
                   showDurationInside && /* @__PURE__ */ jsx2("span", { className: "gantt-tr-taskDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && showProgressInside && /* @__PURE__ */ jsxs2("span", { className: "gantt-tr-progressText", children: [
                     progressWidth,
                     "%"
                   ] }),
-                  !isParent && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
+                  !isParent && !milestone && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
                 ]
               }
             ),
@@ -2760,7 +2931,7 @@ var TaskRow = React2.memo(
               {
                 className: `gantt-tr-leftLabels ${task.locked ? "gantt-tr-leftLabels-locked" : ""}`,
                 style: {
-                  left: `${displayLeft}px`
+                  left: `${visualLeft}px`
                 },
                 children: /* @__PURE__ */ jsx2("span", { className: "gantt-tr-dateLabel gantt-tr-dateLabelLeft", children: dateRangeLabel })
               }
@@ -2771,7 +2942,7 @@ var TaskRow = React2.memo(
                 className: "gantt-tr-lockIcon",
                 style: {
                   position: "absolute",
-                  left: `${displayLeft - 16}px`,
+                  left: `${visualLeft - 16}px`,
                   top: "50%",
                   transform: "translateY(-50%)",
                   width: "12px",
@@ -2791,11 +2962,11 @@ var TaskRow = React2.memo(
               {
                 className: "gantt-tr-rightLabels",
                 style: {
-                  left: `${displayLeft + Math.max(displayWidth, 20) - Math.min(6, Math.max(displayWidth, 20) / 2) + 8}px`,
+                  left: `${visualLeft + Math.max(visualWidth, 20) - Math.min(6, Math.max(visualWidth, 20) / 2) + 8}px`,
                   color: isParent ? task.color || defaultParentBarColor : barColor
                 },
                 children: [
-                  !showDurationInside && /* @__PURE__ */ jsx2("span", { className: "gantt-tr-externalDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
+                  !showDurationInside && !milestone && /* @__PURE__ */ jsx2("span", { className: "gantt-tr-externalDuration", children: isParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && !showProgressInside && /* @__PURE__ */ jsxs2("span", { className: "gantt-tr-externalProgress", children: [
                     progressWidth,
                     "%"
@@ -3044,16 +3215,12 @@ var DependencyLines = React5.memo(({
     const taskMap = new Map(tasksForPositions.map((t) => [t.id, t]));
     const visibleTaskMap = new Map(tasks.map((t) => [t.id, t]));
     tasks.forEach((task, index) => {
-      const startDate = new Date(task.startDate);
-      const endDate = new Date(task.endDate);
-      const computed = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
       const override = dragOverrides?.get(task.id);
-      const resolvedLeft = override?.left ?? computed.left;
-      const resolvedWidth = override?.width ?? computed.width;
+      const computed = resolveTaskHorizontalGeometry(task, monthStart, dayWidth, override);
       indices.set(task.id, index);
       positions.set(task.id, {
-        left: resolvedLeft,
-        right: resolvedLeft + resolvedWidth,
+        left: computed.left,
+        right: computed.right,
         rowTop: index * rowHeight,
         isVirtual: false
       });
@@ -3067,15 +3234,11 @@ var DependencyLines = React5.memo(({
         if (!visibleAncestor) continue;
         const ancestorPosition = positions.get(visibleAncestor.id);
         if (!ancestorPosition) continue;
-        const startDate = new Date(task.startDate);
-        const endDate = new Date(task.endDate);
-        const computed = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
         const override = dragOverrides?.get(task.id);
-        const resolvedLeft = override?.left ?? computed.left;
-        const resolvedWidth = override?.width ?? computed.width;
+        const computed = resolveTaskHorizontalGeometry(task, monthStart, dayWidth, override);
         positions.set(task.id, {
-          left: resolvedLeft,
-          right: resolvedLeft + resolvedWidth,
+          left: computed.left,
+          right: computed.right,
           rowTop: ancestorPosition.rowTop,
           isVirtual: true
         });
@@ -3091,6 +3254,7 @@ var DependencyLines = React5.memo(({
   }, [tasks, allTasks]);
   const lines = useMemo5(() => {
     const tasksForEdges = allTasks ?? tasks;
+    const taskMap = new Map(tasksForEdges.map((task) => [task.id, task]));
     const edges = getAllDependencyEdges(tasksForEdges);
     const lines2 = [];
     for (const edge of edges) {
@@ -3101,9 +3265,11 @@ var DependencyLines = React5.memo(({
       if (!predecessor || !successor) {
         continue;
       }
+      const predecessorTask = taskMap.get(edge.predecessorId);
+      const successorTask = taskMap.get(edge.successorId);
       if (allTasks && collapsedParentIds.size > 0) {
-        const taskMap = new Map(allTasks.map((t) => [t.id, t]));
-        if (areBothHiddenInSameParent(edge.predecessorId, edge.successorId, collapsedParentIds, taskMap)) {
+        const taskMap2 = new Map(allTasks.map((t) => [t.id, t]));
+        if (areBothHiddenInSameParent(edge.predecessorId, edge.successorId, collapsedParentIds, taskMap2)) {
           continue;
         }
       }
@@ -3123,11 +3289,18 @@ var DependencyLines = React5.memo(({
         fromY = predecessor.rowTop + rowHeight - 10;
         toY = successor.rowTop + 6;
       }
-      const fromX = edge.type === "SS" || edge.type === "SF" ? predecessor.left : predecessor.right;
+      let fromX = edge.type === "SS" || edge.type === "SF" ? predecessor.left : predecessor.right;
       const toX = edge.type === "FF" || edge.type === "SF" ? successor.right : successor.left;
+      const stackedMilestonesSameDay = Boolean(
+        predecessorTask && successorTask && isMilestoneTask(predecessorTask) && isMilestoneTask(successorTask) && edge.lag === 0 && new Date(predecessorTask.startDate).toISOString().split("T")[0] === new Date(successorTask.startDate).toISOString().split("T")[0] && predecessor.rowTop !== successor.rowTop && edge.type === "FS"
+      );
+      const finalToX = stackedMilestonesSameDay ? Math.round(((predecessor.left + predecessor.right) / 2 + (successor.left + successor.right) / 2) / 2) : toX;
+      if (stackedMilestonesSameDay) {
+        fromX = finalToX;
+      }
       const arrivesFromRight = edge.type === "FF" || edge.type === "SF";
       const from = { x: fromX, y: fromY };
-      const to = { x: toX, y: toY };
+      const to = { x: finalToX, y: toY };
       const path = calculateDependencyPath(from, to, arrivesFromRight);
       const hasCycle = cycleInfo.has(edge.predecessorId) || cycleInfo.has(edge.successorId);
       lines2.push({
@@ -3136,7 +3309,7 @@ var DependencyLines = React5.memo(({
         hasCycle,
         lag: edge.lag,
         fromX,
-        toX,
+        toX: finalToX,
         fromY,
         reverseOrder,
         isVirtual
@@ -3149,6 +3322,7 @@ var DependencyLines = React5.memo(({
     "svg",
     {
       className: "gantt-dependencies-svg",
+      "data-testid": "dependency-lines-svg",
       width: gridWidth,
       height: svgHeight,
       xmlns: "http://www.w3.org/2000/svg",
@@ -4147,7 +4321,7 @@ var DepChip = ({
       const predecessor = taskById.get(dep.taskId);
       if (!predecessor) return;
       const predStart = parseUTCDate(predecessor.startDate);
-      const predEnd = parseUTCDate(predecessor.endDate);
+      const predEnd = predecessor.type === "milestone" ? predStart : parseUTCDate(predecessor.endDate);
       const origStart = parseUTCDate(task.startDate);
       const origEnd = parseUTCDate(task.endDate);
       const durationMs = origEnd.getTime() - origStart.getTime();
@@ -4398,7 +4572,8 @@ var TaskListRow = React9.memo(
     canDemoteTask = true,
     isLastChild = true,
     nestingDepth = 0,
-    ancestorContinues = [],
+    hasVisibleChildren = false,
+    ancestorLineModes = [],
     customDays,
     isWeekend: isWeekend3,
     businessDays,
@@ -4410,10 +4585,12 @@ var TaskListRow = React9.memo(
     const editingName = editingColumnId === "name";
     const editingDuration = editingColumnId === "duration";
     const editingProgress = editingColumnId === "progress";
+    const normalizedTask = useMemo7(() => normalizeTaskDatesForType(task), [task]);
+    const isMilestone = useMemo7(() => isMilestoneTask(normalizedTask), [normalizedTask]);
     const [nameValue, setNameValue] = useState4("");
     const nameInputRef = useRef4(null);
     const [durationValue, setDurationValue] = useState4(
-      () => getInclusiveDurationDays(task.startDate, task.endDate)
+      () => getInclusiveDurationDays(normalizedTask.startDate, normalizedTask.endDate)
     );
     const durationInputRef = useRef4(null);
     const dependencySearchInputRef = useRef4(null);
@@ -4453,6 +4630,9 @@ var TaskListRow = React9.memo(
       [businessDays, weekendPredicate]
     );
     const isCollapsed = collapsedParentIds.has(task.id);
+    const getHierarchyLineColor = useCallback4((columnDepth) => {
+      return columnDepth % 2 === 0 ? "var(--gantt-hierarchy-line-color)" : "#93c5fd";
+    }, []);
     const isPicking = selectingPredecessorFor != null;
     const isSourceRow = isPicking && selectingPredecessorFor === task.id;
     const [dependencySearchQuery, setDependencySearchQuery] = useState4("");
@@ -4614,14 +4794,14 @@ var TaskListRow = React9.memo(
         e.stopPropagation();
         durationConfirmedRef.current = false;
         setDurationValue(
-          getDuration(task.startDate, task.endDate)
+          isMilestone ? 0 : getDuration(normalizedTask.startDate, normalizedTask.endDate)
         );
         setEditingColumnId("duration");
       },
-      [task.locked, task.startDate, task.endDate, getDuration]
+      [task.locked, normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]
     );
     const applyDurationChange = useCallback4((nextDuration) => {
-      const normalizedDuration = Math.max(1, Math.round(nextDuration) || 1);
+      const normalizedDuration = Math.max(0, Math.round(nextDuration) || 0);
       setDurationValue(normalizedDuration);
     }, []);
     const handleDurationSave = useCallback4(() => {
@@ -4629,19 +4809,26 @@ var TaskListRow = React9.memo(
         durationConfirmedRef.current = false;
         return;
       }
-      const normalizedDuration = Math.max(1, Math.round(durationValue) || 1);
-      onTasksChange?.([
-        {
-          ...task,
-          endDate: getEndDate(task.startDate, normalizedDuration)
-        }
-      ]);
+      const rounded = Math.round(durationValue) || 0;
+      if (isMilestone && rounded > 0) {
+        onTasksChange?.([
+          { ...task, type: "task", endDate: getEndDate(task.startDate, rounded) }
+        ]);
+      } else if (!isMilestone && rounded === 0) {
+        onTasksChange?.([
+          { ...task, type: "milestone", endDate: task.startDate }
+        ]);
+      } else if (!isMilestone && rounded > 0) {
+        onTasksChange?.([
+          { ...task, endDate: getEndDate(task.startDate, rounded) }
+        ]);
+      }
       setEditingColumnId(null);
-    }, [durationValue, task, onTasksChange, getEndDate]);
+    }, [durationValue, task, onTasksChange, getEndDate, isMilestone]);
     const handleDurationCancel = useCallback4(() => {
-      setDurationValue(getDuration(task.startDate, task.endDate));
+      setDurationValue(isMilestone ? 0 : getDuration(normalizedTask.startDate, normalizedTask.endDate));
       setEditingColumnId(null);
-    }, [task.startDate, task.endDate, getDuration]);
+    }, [normalizedTask.startDate, normalizedTask.endDate, getDuration, isMilestone]);
     const handleDurationAdjust = useCallback4(
       (delta) => {
         applyDurationChange(durationValue + delta);
@@ -4653,25 +4840,26 @@ var TaskListRow = React9.memo(
         e.stopPropagation();
         if (e.key === "Enter") {
           durationConfirmedRef.current = true;
-          const normalizedDuration = Math.max(
-            1,
-            Math.round(durationValue) || 1
-          );
-          onTasksChange?.([
-            {
-              ...task,
-              endDate: getEndDate(
-                task.startDate,
-                normalizedDuration
-              )
-            }
-          ]);
+          const rounded = Math.round(durationValue) || 0;
+          if (isMilestone && rounded > 0) {
+            onTasksChange?.([
+              { ...task, type: "task", endDate: getEndDate(task.startDate, rounded) }
+            ]);
+          } else if (!isMilestone && rounded === 0) {
+            onTasksChange?.([
+              { ...task, type: "milestone", endDate: task.startDate }
+            ]);
+          } else if (!isMilestone && rounded > 0) {
+            onTasksChange?.([
+              { ...task, endDate: getEndDate(task.startDate, rounded) }
+            ]);
+          }
           setEditingColumnId(null);
         } else if (e.key === "Escape") {
           handleDurationCancel();
         }
       },
-      [durationValue, task, onTasksChange, handleDurationCancel, getEndDate]
+      [durationValue, task, onTasksChange, handleDurationCancel, getEndDate, isMilestone]
     );
     const handleProgressClick = useCallback4(
       (e) => {
@@ -4742,17 +4930,54 @@ var TaskListRow = React9.memo(
       }
     }, [editingProgress]);
     useEffect4(() => {
-      setDurationValue(getDuration(task.startDate, task.endDate));
-    }, [task.startDate, task.endDate, getDuration]);
+      setDurationValue(getDuration(normalizedTask.startDate, normalizedTask.endDate));
+    }, [normalizedTask.startDate, normalizedTask.endDate, getDuration]);
     useEffect4(() => {
       if (editingDuration && durationInputRef.current) {
         durationInputRef.current.focus();
         durationInputRef.current.select();
       }
     }, [editingDuration]);
+    const emitMilestoneDateChange = useCallback4((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,
+        alignedDate,
+        alignedDate,
+        allTasks,
+        businessDays,
+        weekendPredicate
+      );
+      const normalized = normalizeTaskDatesForType({
+        ...task,
+        startDate: clampedRange.start.toISOString().split("T")[0],
+        endDate: clampedRange.end.toISOString().split("T")[0]
+      });
+      const startDate = parseUTCDate(normalized.startDate);
+      const endDate = parseUTCDate(normalized.endDate);
+      onTasksChange?.([
+        {
+          ...normalized,
+          ...task.dependencies && {
+            dependencies: recalculateIncomingLags(
+              task,
+              startDate,
+              endDate,
+              allTasks,
+              businessDays,
+              weekendPredicate
+            )
+          }
+        }
+      ]);
+    }, [task, onTasksChange, allTasks, businessDays, weekendPredicate]);
     const handleStartDateChange = useCallback4(
       (newDateISO) => {
         if (!newDateISO) return;
+        if (isMilestone) {
+          emitMilestoneDateChange(newDateISO);
+          return;
+        }
         let nextEndISO;
         const normalizedInputStart = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`), 1, weekendPredicate) : /* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`);
         if (businessDays) {
@@ -4799,11 +5024,15 @@ var TaskListRow = React9.memo(
           }
         ]);
       },
-      [task, onTasksChange, businessDays, getDuration, getEndDate, allTasks, weekendPredicate]
+      [task, onTasksChange, businessDays, getDuration, getEndDate, allTasks, weekendPredicate, isMilestone, emitMilestoneDateChange]
     );
     const handleEndDateChange = useCallback4(
       (newDateISO) => {
         if (!newDateISO) return;
+        if (isMilestone) {
+          emitMilestoneDateChange(newDateISO);
+          return;
+        }
         let nextStartISO;
         const normalizedInputEnd = businessDays ? alignToWorkingDay(/* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`), -1, weekendPredicate) : /* @__PURE__ */ new Date(`${newDateISO}T00:00:00.000Z`);
         if (businessDays) {
@@ -4850,7 +5079,7 @@ var TaskListRow = React9.memo(
           }
         ]);
       },
-      [task, onTasksChange, businessDays, getDuration, weekendPredicate, allTasks]
+      [task, onTasksChange, businessDays, getDuration, weekendPredicate, allTasks, isMilestone, emitMilestoneDateChange]
     );
     const handleRowClickInternal = useCallback4(() => {
       onRowClick?.(task.id);
@@ -5121,8 +5350,8 @@ var TaskListRow = React9.memo(
       },
       [selectedChip?.successorId, selectedChip?.predecessorId, selectedChip?.linkType, onRemoveDependency, onChipSelect]
     );
-    const startDateISO = toISODate(task.startDate);
-    const endDateISO = editingDuration ? getEndDate(task.startDate, durationValue) : toISODate(task.endDate);
+    const startDateISO = toISODate(normalizedTask.startDate);
+    const endDateISO = editingDuration ? getEndDate(normalizedTask.startDate, durationValue) : toISODate(normalizedTask.endDate);
     const numberCell = /* @__PURE__ */ jsxs9(
       "div",
       {
@@ -5152,23 +5381,41 @@ var TaskListRow = React9.memo(
     const nameCell = /* @__PURE__ */ jsxs9("div", { className: "gantt-tl-cell gantt-tl-cell-name", children: [
       isChild && !editingName && /* @__PURE__ */ jsxs9(Fragment2, { children: [
         !isFilterHideMode && /* @__PURE__ */ jsxs9(Fragment2, { children: [
-          ancestorContinues.map(
-            (continues, idx) => continues ? /* @__PURE__ */ jsx12(
-              "span",
-              {
-                style: {
-                  position: "absolute",
-                  left: `${idx * 20 + 9}px`,
-                  top: 0,
-                  height: `${rowHeight}px`,
-                  width: "1.5px",
-                  background: "var(--gantt-hierarchy-line-color)",
-                  borderRadius: "1px",
-                  pointerEvents: "none"
+          ancestorLineModes.map(
+            (mode, idx) => mode ? /* @__PURE__ */ jsxs9(React9.Fragment, { children: [
+              /* @__PURE__ */ jsx12(
+                "span",
+                {
+                  "data-testid": `gantt-tl-ancestor-connector-${idx}`,
+                  style: {
+                    position: "absolute",
+                    left: `${idx * 20 + 9}px`,
+                    top: 0,
+                    height: mode === "half" ? `${rowHeight / 2}px` : `${rowHeight}px`,
+                    width: "1.5px",
+                    background: getHierarchyLineColor(idx),
+                    borderRadius: "1px",
+                    pointerEvents: "none"
+                  }
                 }
-              },
-              idx
-            ) : null
+              ),
+              mode === "half" && /* @__PURE__ */ jsx12(
+                "span",
+                {
+                  "data-testid": `gantt-tl-ancestor-connector-cap-${idx}`,
+                  style: {
+                    position: "absolute",
+                    left: `${idx * 20 + 9}px`,
+                    top: `${rowHeight / 2 - 0.75}px`,
+                    width: "5px",
+                    height: "1.5px",
+                    background: getHierarchyLineColor(idx),
+                    borderRadius: "1px",
+                    pointerEvents: "none"
+                  }
+                }
+              )
+            ] }, idx) : null
           ),
           nestingDepth > 0 && /* @__PURE__ */ jsx12(
             "span",
@@ -5178,9 +5425,9 @@ var TaskListRow = React9.memo(
                 position: "absolute",
                 left: `${(nestingDepth - 1) * 20 + 9}px`,
                 top: 0,
-                height: isLastChild ? `${rowHeight / 2}px` : `${rowHeight}px`,
+                height: isLastChild && !hasVisibleChildren ? `${rowHeight / 2}px` : `${rowHeight}px`,
                 width: "1.5px",
-                background: "var(--gantt-hierarchy-line-color)",
+                background: getHierarchyLineColor(nestingDepth - 1),
                 borderRadius: "1px",
                 pointerEvents: "none"
               }
@@ -5195,7 +5442,7 @@ var TaskListRow = React9.memo(
                 top: `${rowHeight / 2 - 0.75}px`,
                 width: "8px",
                 height: "1.5px",
-                background: "var(--gantt-hierarchy-line-color)",
+                background: getHierarchyLineColor(nestingDepth - 1),
                 borderRadius: "1px",
                 pointerEvents: "none"
               }
@@ -5211,7 +5458,7 @@ var TaskListRow = React9.memo(
                 width: "4px",
                 height: "4px",
                 borderRadius: "50%",
-                background: "var(--gantt-hierarchy-line-color)",
+                background: getHierarchyLineColor(nestingDepth - 1),
                 pointerEvents: "none"
               }
             }
@@ -5227,7 +5474,7 @@ var TaskListRow = React9.memo(
                 top: `${rowHeight / 2 + 7}px`,
                 height: `${rowHeight / 2 - 7}px`,
                 width: "1.5px",
-                background: "var(--gantt-hierarchy-line-color)",
+                background: getHierarchyLineColor(nestingDepth),
                 borderRadius: "1px",
                 pointerEvents: "none"
               }
@@ -5257,7 +5504,7 @@ var TaskListRow = React9.memo(
               top: `${rowHeight / 2 + 7}px`,
               height: `${rowHeight / 2 - 7}px`,
               width: "1.5px",
-              background: "var(--gantt-hierarchy-line-color)",
+              background: getHierarchyLineColor(nestingDepth),
               borderRadius: "1px",
               pointerEvents: "none"
             }
@@ -5528,10 +5775,10 @@ var TaskListRow = React9.memo(
                   {
                     ref: durationInputRef,
                     type: "number",
-                    min: 1,
+                    min: 0,
                     step: 1,
                     value: durationValue,
-                    onChange: (e) => applyDurationChange(parseInt(e.target.value, 10) || 1),
+                    onChange: (e) => applyDurationChange(parseInt(e.target.value, 10) || 0),
                     onBlur: handleDurationSave,
                     onKeyDown: handleDurationKeyDown,
                     className: "gantt-tl-number-input"
@@ -5592,14 +5839,11 @@ var TaskListRow = React9.memo(
               ]
             }
           ),
-          /* @__PURE__ */ jsxs9(
+          /* @__PURE__ */ jsx12(
             "span",
             {
               style: editingDuration ? { visibility: "hidden", pointerEvents: "none" } : void 0,
-              children: [
-                getDuration(task.startDate, task.endDate),
-                "\u0434"
-              ]
+              children: isMilestone ? "\u25C6" : `${getDuration(normalizedTask.startDate, normalizedTask.endDate)}\u0434`
             }
           )
         ]
@@ -6247,20 +6491,41 @@ var TaskList = ({
     }
     return last;
   }, [visibleTasks]);
-  const ancestorContinuesMap = useMemo8(() => {
+  const visibleParentIds = useMemo8(() => {
+    const parentIds = /* @__PURE__ */ new Set();
+    for (const task of visibleTasks) {
+      if (task.parentId) parentIds.add(task.parentId);
+    }
+    return parentIds;
+  }, [visibleTasks]);
+  const ancestorLineModesMap = useMemo8(() => {
     const taskById = new Map(tasks.map((t) => [t.id, t]));
+    const isDescendantOf = (taskId, ancestorId) => {
+      let current = taskById.get(taskId);
+      while (current?.parentId && taskById.has(current.parentId)) {
+        if (current.parentId === ancestorId) return true;
+        current = taskById.get(current.parentId);
+      }
+      return false;
+    };
     const map = /* @__PURE__ */ new Map();
-    for (const task of visibleTasks) {
-      const continues = [];
+    for (let index = 0; index < visibleTasks.length; index++) {
+      const task = visibleTasks[index];
+      const ancestorIds = [];
       let current = taskById.get(task.id);
       while (current?.parentId && taskById.has(current.parentId)) {
-        continues.unshift(!lastChildIds.has(current.id));
+        ancestorIds.unshift(current.parentId);
         current = taskById.get(current.parentId);
       }
-      map.set(task.id, continues.slice(0, -1));
+      const ancestorsAboveParent = ancestorIds.slice(0, -1);
+      const modes = ancestorsAboveParent.map((ancestorId) => {
+        const hasLaterVisibleDescendant = visibleTasks.slice(index + 1).some((laterTask) => isDescendantOf(laterTask.id, ancestorId));
+        return hasLaterVisibleDescendant ? "full" : "half";
+      });
+      map.set(task.id, modes);
     }
     return map;
-  }, [tasks, visibleTasks, lastChildIds]);
+  }, [tasks, visibleTasks]);
   const handleRowClick = useCallback5((taskId) => {
     onTaskSelect?.(taskId);
   }, [onTaskSelect]);
@@ -6805,7 +7070,8 @@ var TaskList = ({
                 canDemoteTask,
                 isLastChild: lastChildIds.has(task.id),
                 nestingDepth: nestingDepthMap.get(task.id) ?? 0,
-                ancestorContinues: ancestorContinuesMap.get(task.id) ?? [],
+                hasVisibleChildren: visibleParentIds.has(task.id),
+                ancestorLineModes: ancestorLineModesMap.get(task.id) ?? [],
                 customDays,
                 isWeekend: isWeekend3,
                 businessDays,
@@ -7543,6 +7809,8 @@ export {
   calculateDependencyPath,
   calculateGridLines,
   calculateGridWidth,
+  calculateMilestoneConnectionBounds,
+  calculateMilestoneGeometry,
   calculateMonthGridLines,
   calculateOrthogonalPath,
   calculateSuccessorDate,
@@ -7594,6 +7862,7 @@ export {
   nameContains,
   normalizeDependencyLag,
   normalizeHierarchyTasks,
+  normalizePredecessorDates,
   normalizeTaskDates,
   normalizeUTCDate,
   not,
@@ -7609,6 +7878,7 @@ export {
   removeDependenciesBetweenTasks,
   resizeTaskWithCascade,
   resolveDateRangeFromPixels,
+  resolveTaskHorizontalGeometry,
   shiftBusinessDayOffset,
   subtractBusinessDays2 as subtractBusinessDays,
   universalCascade,