gantt-lib 0.53.0 → 0.60.0

package/dist/index.js

@@ -33,32 +33,49 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/utils/dateUtils.ts
-var dateUtils_exports = {};
-__export(dateUtils_exports, {
-  addBusinessDays: () => addBusinessDays,
-  createCustomDayPredicate: () => createCustomDayPredicate,
-  createDateKey: () => createDateKey,
-  formatDateLabel: () => formatDateLabel,
-  formatDateRangeLabel: () => formatDateRangeLabel,
-  getBusinessDaysCount: () => getBusinessDaysCount,
-  getDayOffset: () => getDayOffset,
-  getMonthBlocks: () => getMonthBlocks,
-  getMonthDays: () => getMonthDays,
-  getMonthSpans: () => getMonthSpans,
-  getMultiMonthDays: () => getMultiMonthDays,
-  getWeekBlocks: () => getWeekBlocks,
-  getWeekSpans: () => getWeekSpans,
-  getYearSpans: () => getYearSpans,
-  isToday: () => isToday,
-  isWeekend: () => isWeekend,
-  normalizeTaskDates: () => normalizeTaskDates,
-  parseUTCDate: () => parseUTCDate,
-  subtractBusinessDays: () => subtractBusinessDays
-});
+// src/core/scheduling/dateMath.ts
+function normalizeUTCDate(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function parseDateOnly(date) {
+  const parsed = typeof date === "string" ? /* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(date);
+  return normalizeUTCDate(parsed);
+}
+function getBusinessDayOffset(fromDate, toDate, weekendPredicate) {
+  const from = normalizeUTCDate(fromDate);
+  const to = normalizeUTCDate(toDate);
+  if (from.getTime() === to.getTime()) {
+    return 0;
+  }
+  const step = to.getTime() > from.getTime() ? 1 : -1;
+  const current = new Date(from);
+  let offset = 0;
+  while (current.getTime() !== to.getTime()) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      offset += step;
+    }
+  }
+  return offset;
+}
+function shiftBusinessDayOffset(date, offset, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  if (offset === 0) {
+    return current;
+  }
+  const step = offset > 0 ? 1 : -1;
+  let remaining = Math.abs(offset);
+  while (remaining > 0) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      remaining--;
+    }
+  }
+  return current;
+}
 function getBusinessDaysCount(startDate, endDate, weekendPredicate) {
-  const start = parseUTCDate(startDate);
-  const end = parseUTCDate(endDate);
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
   let count = 0;
   const current = new Date(start);
   while (current.getTime() <= end.getTime()) {
@@ -70,7 +87,7 @@ function getBusinessDaysCount(startDate, endDate, weekendPredicate) {
   return Math.max(1, count);
 }
 function addBusinessDays(startDate, businessDays, weekendPredicate) {
-  const start = parseUTCDate(startDate);
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
   const current = new Date(start);
   let targetDays = Math.max(1, businessDays);
   let businessDaysCounted = 0;
@@ -82,10 +99,10 @@ function addBusinessDays(startDate, businessDays, weekendPredicate) {
       current.setUTCDate(current.getUTCDate() + 1);
     }
   }
-  return current.toISOString().split("T")[0];
+  return current;
 }
 function subtractBusinessDays(endDate, businessDays, weekendPredicate) {
-  const end = parseUTCDate(endDate);
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
   const current = new Date(end);
   let targetDays = Math.max(1, businessDays);
   let businessDaysCounted = 0;
@@ -97,12 +114,70 @@ function subtractBusinessDays(endDate, businessDays, weekendPredicate) {
       current.setUTCDate(current.getUTCDate() - 1);
     }
   }
-  return current.toISOString().split("T")[0];
+  return current;
+}
+function alignToWorkingDay(date, direction, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  while (weekendPredicate(current)) {
+    current.setUTCDate(current.getUTCDate() + direction);
+  }
+  return current;
+}
+function getTaskDuration(startDate, endDate, businessDays = false, weekendPredicate) {
+  const start = parseDateOnly(startDate);
+  const end = parseDateOnly(endDate);
+  if (businessDays && weekendPredicate) {
+    return getBusinessDaysCount(start, end, weekendPredicate);
+  }
+  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
+}
+var DAY_MS;
+var init_dateMath = __esm({
+  "src/core/scheduling/dateMath.ts"() {
+    "use strict";
+    DAY_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/utils/dateUtils.ts
+var dateUtils_exports = {};
+__export(dateUtils_exports, {
+  addBusinessDays: () => addBusinessDays2,
+  createCustomDayPredicate: () => createCustomDayPredicate,
+  createDateKey: () => createDateKey,
+  formatDateLabel: () => formatDateLabel,
+  formatDateRangeLabel: () => formatDateRangeLabel,
+  getBusinessDaysCount: () => getBusinessDaysCount2,
+  getDayOffset: () => getDayOffset,
+  getMonthBlocks: () => getMonthBlocks,
+  getMonthDays: () => getMonthDays,
+  getMonthSpans: () => getMonthSpans,
+  getMultiMonthDays: () => getMultiMonthDays,
+  getWeekBlocks: () => getWeekBlocks,
+  getWeekSpans: () => getWeekSpans,
+  getYearSpans: () => getYearSpans,
+  isToday: () => isToday,
+  isWeekend: () => isWeekend,
+  normalizeTaskDates: () => normalizeTaskDates,
+  parseUTCDate: () => parseUTCDate,
+  subtractBusinessDays: () => subtractBusinessDays2
+});
+function getBusinessDaysCount2(startDate, endDate, weekendPredicate) {
+  return getBusinessDaysCount(startDate, endDate, weekendPredicate);
+}
+function addBusinessDays2(startDate, businessDays, weekendPredicate) {
+  const result = addBusinessDays(startDate, businessDays, weekendPredicate);
+  return result.toISOString().split("T")[0];
+}
+function subtractBusinessDays2(endDate, businessDays, weekendPredicate) {
+  const result = subtractBusinessDays(endDate, businessDays, weekendPredicate);
+  return result.toISOString().split("T")[0];
 }
 var parseUTCDate, getMonthDays, getDayOffset, isToday, isWeekend, createDateKey, createCustomDayPredicate, getMultiMonthDays, getMonthSpans, formatDateLabel, MONTH_ABBR, formatDateRangeLabel, getWeekBlocks, getWeekSpans, getMonthBlocks, getYearSpans, normalizeTaskDates;
 var init_dateUtils = __esm({
   "src/utils/dateUtils.ts"() {
     "use strict";
+    init_dateMath();
     parseUTCDate = (date) => {
       if (typeof date === "string") {
         const dateStr = date.includes("T") ? date : `${date}T00:00:00Z`;
@@ -431,6 +506,7 @@ var index_exports = {};
 __export(index_exports, {
   Button: () => Button,
   Calendar: () => Calendar,
+  DAY_MS: () => DAY_MS,
   DatePicker: () => DatePicker,
   DragGuideLines: () => DragGuideLines_default,
   GanttChart: () => GanttChart,
@@ -443,7 +519,7 @@ __export(index_exports, {
   TaskRow: () => TaskRow_default,
   TimeScaleHeader: () => TimeScaleHeader_default,
   TodayIndicator: () => TodayIndicator_default,
-  addBusinessDays: () => addBusinessDays,
+  addBusinessDays: () => addBusinessDays2,
   alignToWorkingDay: () => alignToWorkingDay,
   and: () => and,
   areTasksHierarchicallyRelated: () => areTasksHierarchicallyRelated,
@@ -476,7 +552,8 @@ __export(index_exports, {
   formatDateRangeLabel: () => formatDateRangeLabel,
   getAllDependencyEdges: () => getAllDependencyEdges,
   getAllDescendants: () => getAllDescendants,
-  getBusinessDaysCount: () => getBusinessDaysCount,
+  getBusinessDayOffset: () => getBusinessDayOffset,
+  getBusinessDaysCount: () => getBusinessDaysCount2,
   getChildren: () => getChildren,
   getCursorForPosition: () => getCursorForPosition,
   getDayOffset: () => getDayOffset,
@@ -503,15 +580,18 @@ __export(index_exports, {
   normalizeDependencyLag: () => normalizeDependencyLag,
   normalizeHierarchyTasks: () => normalizeHierarchyTasks,
   normalizeTaskDates: () => normalizeTaskDates,
+  normalizeUTCDate: () => normalizeUTCDate,
   not: () => not,
   or: () => or,
+  parseDateOnly: () => parseDateOnly,
   parseUTCDate: () => parseUTCDate,
   pixelsToDate: () => pixelsToDate,
   progressInRange: () => progressInRange,
   recalculateIncomingLags: () => recalculateIncomingLags,
   reflowTasksOnModeSwitch: () => reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks: () => removeDependenciesBetweenTasks,
-  subtractBusinessDays: () => subtractBusinessDays,
+  shiftBusinessDayOffset: () => shiftBusinessDayOffset,
+  subtractBusinessDays: () => subtractBusinessDays2,
   universalCascade: () => universalCascade,
   useTaskDrag: () => useTaskDrag,
   validateDependencies: () => validateDependencies,
@@ -523,43 +603,11 @@ module.exports = __toCommonJS(index_exports);
 var import_react13 = require("react");
 init_dateUtils();
 
-// src/utils/dependencyUtils.ts
-init_dateUtils();
-function normalizeUTCDate(date) {
-  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-}
-function getBusinessDayOffset(fromDate, toDate, weekendPredicate) {
-  const from = normalizeUTCDate(fromDate);
-  const to = normalizeUTCDate(toDate);
-  if (from.getTime() === to.getTime()) {
-    return 0;
-  }
-  const step = to.getTime() > from.getTime() ? 1 : -1;
-  const current = new Date(from);
-  let offset = 0;
-  while (current.getTime() !== to.getTime()) {
-    current.setUTCDate(current.getUTCDate() + step);
-    if (!weekendPredicate(current)) {
-      offset += step;
-    }
-  }
-  return offset;
-}
-function shiftBusinessDayOffset(date, offset, weekendPredicate) {
-  const current = normalizeUTCDate(date);
-  if (offset === 0) {
-    return current;
-  }
-  const step = offset > 0 ? 1 : -1;
-  let remaining = Math.abs(offset);
-  while (remaining > 0) {
-    current.setUTCDate(current.getUTCDate() + step);
-    if (!weekendPredicate(current)) {
-      remaining--;
-    }
-  }
-  return current;
-}
+// src/core/scheduling/index.ts
+init_dateMath();
+
+// src/core/scheduling/dependencies.ts
+init_dateMath();
 function getDependencyLag(dep) {
   return Number.isFinite(dep.lag) ? dep.lag : 0;
 }
@@ -575,71 +623,268 @@ function normalizeDependencyLag(linkType, lag, predecessorStart, predecessorEnd,
   );
   return Math.max(-predecessorDuration, lag);
 }
-function alignToWorkingDay(date, direction, weekendPredicate) {
-  const current = normalizeUTCDate(date);
-  while (weekendPredicate(current)) {
-    current.setUTCDate(current.getUTCDate() + direction);
-  }
-  return current;
-}
-function getTaskDuration(startDate, endDate, businessDays = false, weekendPredicate) {
-  const start = parseDateOnly(startDate);
-  const end = parseDateOnly(endDate);
-  if (businessDays && weekendPredicate) {
-    return getBusinessDaysCount(start, end, weekendPredicate);
-  }
-  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
-}
-function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
-  const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
-  if (businessDays && weekendPredicate) {
-    return {
-      start: normalizedStart,
-      end: parseDateOnly(addBusinessDays(normalizedStart, duration, weekendPredicate))
-    };
+function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd, businessDays = false, weekendPredicate) {
+  const pS = Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate());
+  const pE = Date.UTC(predEnd.getUTCFullYear(), predEnd.getUTCMonth(), predEnd.getUTCDate());
+  const sS = Date.UTC(succStart.getUTCFullYear(), succStart.getUTCMonth(), succStart.getUTCDate());
+  const sE = Date.UTC(succEnd.getUTCFullYear(), succEnd.getUTCMonth(), succEnd.getUTCDate());
+  if (!businessDays || !weekendPredicate) {
+    switch (linkType) {
+      case "FS":
+        return normalizeDependencyLag(
+          linkType,
+          Math.round((sS - pE) / DAY_MS) - 1,
+          predStart,
+          predEnd,
+          businessDays,
+          weekendPredicate
+        );
+      case "SS":
+        return Math.round((sS - pS) / DAY_MS);
+      case "FF":
+        return Math.round((sE - pE) / DAY_MS);
+      case "SF":
+        return Math.round((sE - pS) / DAY_MS) + 1;
+    }
   }
-  return {
-    start: normalizedStart,
-    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS)
-  };
-}
-function buildTaskRangeFromEnd(endDate, duration, businessDays = false, weekendPredicate, snapDirection = -1) {
-  const normalizedEnd = businessDays && weekendPredicate ? alignToWorkingDay(endDate, snapDirection, weekendPredicate) : normalizeUTCDate(endDate);
-  if (businessDays && weekendPredicate) {
-    return {
-      start: parseDateOnly(subtractBusinessDays(normalizedEnd, duration, weekendPredicate)),
-      end: normalizedEnd
-    };
+  const anchorDate = linkType === "SS" || linkType === "SF" ? predStart : predEnd;
+  const targetDate = linkType === "FS" || linkType === "SS" ? succStart : succEnd;
+  const businessOffset = getBusinessDayOffset(anchorDate, targetDate, weekendPredicate);
+  switch (linkType) {
+    case "FS":
+      return normalizeDependencyLag(
+        linkType,
+        businessOffset - 1,
+        predStart,
+        predEnd,
+        businessDays,
+        weekendPredicate
+      );
+    case "SS":
+      return businessOffset;
+    case "FF":
+      return businessOffset;
+    case "SF":
+      return businessOffset + 1;
   }
-  return {
-    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS),
-    end: normalizedEnd
-  };
 }
-function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays = false, weekendPredicate, snapDirection = 1) {
-  return buildTaskRangeFromStart(
-    proposedStart,
-    getTaskDuration(originalStart, originalEnd, businessDays, weekendPredicate),
+function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0, businessDays = false, weekendPredicate) {
+  const normalizedLag = normalizeDependencyLag(
+    linkType,
+    lag,
+    predecessorStart,
+    predecessorEnd,
     businessDays,
-    weekendPredicate,
-    snapDirection
+    weekendPredicate
   );
-}
-function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate) {
-  if (!task.dependencies?.length) {
-    return { start: proposedStart, end: proposedEnd };
-  }
-  let minAllowedStart = null;
-  for (const dep of task.dependencies) {
-    if (dep.type !== "FS") {
-      continue;
-    }
-    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
-    if (!predecessor) {
-      continue;
+  if (!businessDays || !weekendPredicate) {
+    switch (linkType) {
+      case "FS":
+        return new Date(predecessorEnd.getTime() + (normalizedLag + 1) * DAY_MS);
+      case "SS":
+        return new Date(predecessorStart.getTime() + normalizedLag * DAY_MS);
+      case "FF":
+        return new Date(predecessorEnd.getTime() + normalizedLag * DAY_MS);
+      case "SF":
+        return new Date(predecessorStart.getTime() + (normalizedLag - 1) * DAY_MS);
     }
-    const predecessorStart = parseDateOnly(predecessor.startDate);
-    const predecessorEnd = parseDateOnly(predecessor.endDate);
+  }
+  const anchorDate = linkType === "FS" || linkType === "FF" ? predecessorEnd : predecessorStart;
+  let offset;
+  switch (linkType) {
+    case "FS":
+      offset = normalizedLag + 1;
+      break;
+    case "SS":
+      offset = normalizedLag;
+      break;
+    case "FF":
+      offset = normalizedLag;
+      break;
+    case "SF":
+      offset = normalizedLag - 1;
+      break;
+  }
+  return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
+}
+
+// src/core/scheduling/cascade.ts
+init_dateMath();
+
+// src/core/scheduling/hierarchy.ts
+function getChildren(parentId, tasks) {
+  return tasks.filter((t) => t.parentId === parentId);
+}
+function isTaskParent(taskId, tasks) {
+  return tasks.some((t) => t.parentId === taskId);
+}
+function computeParentDates(parentId, tasks) {
+  const children = getChildren(parentId, tasks);
+  if (children.length === 0) {
+    const parent = tasks.find((t) => t.id === parentId);
+    const start = parent ? new Date(parent.startDate) : /* @__PURE__ */ new Date();
+    const end = parent ? new Date(parent.endDate) : /* @__PURE__ */ new Date();
+    return { startDate: start, endDate: end };
+  }
+  const startDates = children.map((c) => new Date(c.startDate));
+  const endDates = children.map((c) => new Date(c.endDate));
+  const minTime = Math.min(...startDates.map((d) => d.getTime()));
+  const maxTime = Math.max(...endDates.map((d) => d.getTime()));
+  return {
+    startDate: new Date(minTime),
+    endDate: new Date(maxTime)
+  };
+}
+function computeParentProgress(parentId, tasks) {
+  const children = getChildren(parentId, tasks);
+  if (children.length === 0) {
+    return 0;
+  }
+  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const child of children) {
+    const start = new Date(child.startDate).getTime();
+    const end = new Date(child.endDate).getTime();
+    const duration = (end - start + DAY_MS3) / DAY_MS3;
+    const progress = child.progress ?? 0;
+    totalWeight += duration;
+    weightedSum += duration * progress;
+  }
+  if (totalWeight === 0) {
+    return 0;
+  }
+  return Math.round(weightedSum / totalWeight * 10) / 10;
+}
+function getAllDescendants(parentId, tasks) {
+  const descendants = [];
+  const visited = /* @__PURE__ */ new Set();
+  function collectChildren(taskId) {
+    if (visited.has(taskId)) return;
+    visited.add(taskId);
+    const children = getChildren(taskId, tasks);
+    for (const child of children) {
+      descendants.push(child);
+      collectChildren(child.id);
+    }
+  }
+  collectChildren(parentId);
+  return descendants;
+}
+function getAllDependencyEdges(tasks) {
+  const edges = [];
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        edges.push({
+          predecessorId: dep.taskId,
+          successorId: task.id,
+          type: dep.type,
+          lag: dep.lag ?? 0
+        });
+      }
+    }
+  }
+  return edges;
+}
+function removeDependenciesBetweenTasks(taskId1, taskId2, tasks) {
+  return tasks.map((task) => {
+    if (task.id === taskId1 || task.id === taskId2) {
+      if (!task.dependencies) return task;
+      const otherTaskId = task.id === taskId1 ? taskId2 : taskId1;
+      const filteredDependencies = task.dependencies.filter((dep) => dep.taskId !== otherTaskId);
+      if (filteredDependencies.length === task.dependencies.length) {
+        return task;
+      }
+      return {
+        ...task,
+        dependencies: filteredDependencies.length > 0 ? filteredDependencies : void 0
+      };
+    }
+    return task;
+  });
+}
+function findParentId(taskId, tasks) {
+  const task = tasks.find((t) => t.id === taskId);
+  return task?.parentId;
+}
+function isAncestorTask(ancestorId, taskId, tasks) {
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const visited = /* @__PURE__ */ new Set();
+  let current = taskById.get(taskId);
+  while (current?.parentId) {
+    if (current.parentId === ancestorId) {
+      return true;
+    }
+    if (visited.has(current.parentId)) {
+      return false;
+    }
+    visited.add(current.parentId);
+    current = taskById.get(current.parentId);
+  }
+  return false;
+}
+function areTasksHierarchicallyRelated(taskId1, taskId2, tasks) {
+  if (taskId1 === taskId2) {
+    return true;
+  }
+  return isAncestorTask(taskId1, taskId2, tasks) || isAncestorTask(taskId2, taskId1, tasks);
+}
+
+// src/core/scheduling/commands.ts
+init_dateMath();
+function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
+  const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
+  if (businessDays && weekendPredicate) {
+    return {
+      start: normalizedStart,
+      end: parseDateOnly(addBusinessDays(normalizedStart, duration, weekendPredicate))
+    };
+  }
+  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  return {
+    start: normalizedStart,
+    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS3)
+  };
+}
+function buildTaskRangeFromEnd(endDate, duration, businessDays = false, weekendPredicate, snapDirection = -1) {
+  const normalizedEnd = businessDays && weekendPredicate ? alignToWorkingDay(endDate, snapDirection, weekendPredicate) : normalizeUTCDate(endDate);
+  if (businessDays && weekendPredicate) {
+    return {
+      start: parseDateOnly(subtractBusinessDays(normalizedEnd, duration, weekendPredicate)),
+      end: normalizedEnd
+    };
+  }
+  const DAY_MS3 = 24 * 60 * 60 * 1e3;
+  return {
+    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS3),
+    end: normalizedEnd
+  };
+}
+function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays = false, weekendPredicate, snapDirection = 1) {
+  return buildTaskRangeFromStart(
+    proposedStart,
+    getTaskDuration(originalStart, originalEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate,
+    snapDirection
+  );
+}
+function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate) {
+  if (!task.dependencies?.length) {
+    return { start: proposedStart, end: proposedEnd };
+  }
+  let minAllowedStart = null;
+  for (const dep of task.dependencies) {
+    if (dep.type !== "FS") {
+      continue;
+    }
+    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      continue;
+    }
+    const predecessorStart = parseDateOnly(predecessor.startDate);
+    const predecessorEnd = parseDateOnly(predecessor.endDate);
     const predecessorDuration = getTaskDuration(
       predecessorStart,
       predecessorEnd,
@@ -668,193 +913,85 @@ function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks,
     weekendPredicate
   );
 }
-function parseDateOnly(date) {
-  const parsed = typeof date === "string" ? /* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(date);
-  return normalizeUTCDate(parsed);
-}
-function buildAdjacencyList(tasks) {
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
-  const graph = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    const successors = [];
-    for (const otherTask of tasks) {
-      if (otherTask.dependencies) {
-        for (const dep of otherTask.dependencies) {
-          if (dep.taskId === task.id) {
-            successors.push(otherTask.id);
-            break;
-          }
-        }
-      }
-    }
-    graph.set(task.id, successors);
-  }
-  return graph;
-}
-function detectCycles(tasks) {
-  const graph = buildAdjacencyList(tasks);
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const path = [];
-  function dfs(taskId) {
-    if (visiting.has(taskId)) {
-      return true;
-    }
-    if (visited.has(taskId)) {
-      return false;
-    }
-    visiting.add(taskId);
-    path.push(taskId);
-    const successors = graph.get(taskId) || [];
-    for (const successor of successors) {
-      if (dfs(successor)) {
-        return true;
-      }
-    }
-    visiting.delete(taskId);
-    path.pop();
-    visited.add(taskId);
-    return false;
-  }
-  for (const task of tasks) {
-    if (dfs(task.id)) {
-      return { hasCycle: true, cyclePath: [...path] };
-    }
-  }
-  return { hasCycle: false };
-}
-function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd, businessDays = false, weekendPredicate) {
-  const DAY_MS3 = 24 * 60 * 60 * 1e3;
-  const pS = Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate());
-  const pE = Date.UTC(predEnd.getUTCFullYear(), predEnd.getUTCMonth(), predEnd.getUTCDate());
-  const sS = Date.UTC(succStart.getUTCFullYear(), succStart.getUTCMonth(), succStart.getUTCDate());
-  const sE = Date.UTC(succEnd.getUTCFullYear(), succEnd.getUTCMonth(), succEnd.getUTCDate());
-  if (!businessDays || !weekendPredicate) {
-    switch (linkType) {
-      case "FS":
-        return normalizeDependencyLag(
-          linkType,
-          Math.round((sS - pE) / DAY_MS3) - 1,
-          predStart,
-          predEnd,
-          businessDays,
-          weekendPredicate
-        );
-      case "SS":
-        return Math.round((sS - pS) / DAY_MS3);
-      case "FF":
-        return Math.round((sE - pE) / DAY_MS3);
-      case "SF":
-        return Math.round((sE - pS) / DAY_MS3) + 1;
-    }
-  }
-  const anchorDate = linkType === "SS" || linkType === "SF" ? predStart : predEnd;
-  const targetDate = linkType === "FS" || linkType === "SS" ? succStart : succEnd;
-  const businessOffset = getBusinessDayOffset(anchorDate, targetDate, weekendPredicate);
-  switch (linkType) {
-    case "FS":
-      return normalizeDependencyLag(
-        linkType,
-        businessOffset - 1,
-        predStart,
-        predEnd,
-        businessDays,
-        weekendPredicate
-      );
-    case "SS":
-      return businessOffset;
-    case "FF":
-      return businessOffset;
-    case "SF":
-      return businessOffset + 1;
-  }
-}
-function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0, businessDays = false, weekendPredicate) {
-  const normalizedLag = normalizeDependencyLag(
-    linkType,
-    lag,
-    predecessorStart,
-    predecessorEnd,
-    businessDays,
-    weekendPredicate
-  );
-  if (!businessDays || !weekendPredicate) {
-    switch (linkType) {
-      case "FS":
-        return new Date(predecessorEnd.getTime() + (normalizedLag + 1) * DAY_MS);
-      case "SS":
-        return new Date(predecessorStart.getTime() + normalizedLag * DAY_MS);
-      case "FF":
-        return new Date(predecessorEnd.getTime() + normalizedLag * DAY_MS);
-      case "SF":
-        return new Date(predecessorStart.getTime() + (normalizedLag - 1) * DAY_MS);
+function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate) {
+  if (!task.dependencies) return [];
+  return task.dependencies.map((dep) => {
+    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      return { ...dep, lag: getDependencyLag(dep) };
     }
-  }
-  const anchorDate = linkType === "FS" || linkType === "FF" ? predecessorEnd : predecessorStart;
-  let offset;
-  switch (linkType) {
-    case "FS":
-      offset = normalizedLag + 1;
-      break;
-    case "SS":
-      offset = normalizedLag;
-      break;
-    case "FF":
-      offset = normalizedLag;
-      break;
-    case "SF":
-      offset = normalizedLag - 1;
-      break;
-  }
-  return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
+    const predecessorStart = new Date(predecessor.startDate);
+    const predecessorEnd = new Date(predecessor.endDate);
+    const nextLag = computeLagFromDates(
+      dep.type,
+      predecessorStart,
+      predecessorEnd,
+      newStartDate,
+      newEndDate,
+      businessDays,
+      weekendPredicate
+    );
+    return { ...dep, lag: nextLag };
+  });
 }
-function validateDependencies(tasks) {
-  const errors = [];
-  const taskIds = new Set(tasks.map((t) => t.id));
-  for (const task of tasks) {
-    if (task.dependencies) {
-      for (const dep of task.dependencies) {
-        if (!taskIds.has(dep.taskId)) {
-          errors.push({
-            type: "missing-task",
-            taskId: task.id,
-            message: `Dependency references non-existent task: ${dep.taskId}`,
-            relatedTaskIds: [dep.taskId]
-          });
-        }
-      }
-    }
+function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
+  const dayOffset = Math.round(left / dayWidth);
+  const rawStartDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + dayOffset
+  ));
+  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
+  const rawEndDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + rawEndOffset
+  ));
+  if (!(businessDays && weekendPredicate)) {
+    return { start: rawStartDate, end: rawEndDate };
   }
-  for (const task of tasks) {
-    if (!task.dependencies) continue;
-    for (const dep of task.dependencies) {
-      if (!taskIds.has(dep.taskId)) {
-        continue;
-      }
-      if (areTasksHierarchicallyRelated(task.id, dep.taskId, tasks)) {
-        errors.push({
-          type: "constraint",
-          taskId: task.id,
-          message: `Dependencies between parent and child tasks are not allowed: ${dep.taskId} -> ${task.id}`,
-          relatedTaskIds: [dep.taskId, task.id]
-        });
-      }
-    }
+  if (mode === "move") {
+    const originalStart2 = new Date(task.startDate);
+    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
+    return moveTaskRange(
+      task.startDate,
+      task.endDate,
+      rawStartDate,
+      true,
+      weekendPredicate,
+      snapDirection2
+    );
   }
-  const cycleResult = detectCycles(tasks);
-  if (cycleResult.hasCycle && cycleResult.cyclePath) {
-    errors.push({
-      type: "cycle",
-      taskId: cycleResult.cyclePath[0],
-      message: "Circular dependency detected",
-      relatedTaskIds: cycleResult.cyclePath
-    });
+  if (mode === "resize-right") {
+    const fixedStart = new Date(task.startDate);
+    const originalEnd = new Date(task.endDate);
+    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
+    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
+    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
+    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
   }
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
+  const fixedEnd = new Date(task.endDate);
+  const originalStart = new Date(task.startDate);
+  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
+  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
+  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
+  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
+}
+function clampDateRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
+  if (mode === "resize-right") {
+    return range;
+  }
+  return clampTaskRangeForIncomingFS(
+    task,
+    range.start,
+    range.end,
+    allTasks,
+    businessDays,
+    weekendPredicate
+  );
 }
+
+// src/core/scheduling/cascade.ts
 function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
   const successorMap = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
@@ -918,225 +1055,85 @@ function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascad
         visited.add(child.id);
         updatedDates.set(child.id, { start: newChildStart, end: newChildEnd });
         result.push({
-          ...child,
-          startDate: newChildStart.toISOString().split("T")[0],
-          endDate: newChildEnd.toISOString().split("T")[0]
-        });
-        queue.push(child.id);
-      }
-    }
-    for (const task of allTasks) {
-      if (visited.has(task.id) || !task.dependencies || task.locked) continue;
-      for (const dep of task.dependencies) {
-        if (dep.taskId !== currentId) continue;
-        const orig = taskById.get(task.id);
-        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));
-        let newSuccStart;
-        let newSuccEnd;
-        if (dep.type === "FS" || dep.type === "SS") {
-          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromStart(constraintDate, duration));
-        } else {
-          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromEnd(constraintDate, duration));
-        }
-        visited.add(task.id);
-        updatedDates.set(task.id, { start: newSuccStart, end: newSuccEnd });
-        result.push({
-          ...task,
-          startDate: newSuccStart.toISOString().split("T")[0],
-          endDate: newSuccEnd.toISOString().split("T")[0]
-        });
-        queue.push(task.id);
-        break;
-      }
-    }
-  }
-  return result;
-}
-function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes) {
-  const allTypesSuccessorMap = /* @__PURE__ */ new Map();
-  for (const task of allTasks) {
-    allTypesSuccessorMap.set(task.id, []);
-  }
-  for (const task of allTasks) {
-    if (!task.dependencies) continue;
-    for (const dep of task.dependencies) {
-      const list = allTypesSuccessorMap.get(dep.taskId) ?? [];
-      list.push(task);
-      allTypesSuccessorMap.set(dep.taskId, list);
-    }
-  }
-  const directChildren = getChildren(changedTaskId, allTasks);
-  const directSuccessors = getSuccessorChain(changedTaskId, allTasks, firstLevelLinkTypes);
-  const initialChain = [...directChildren, ...directSuccessors].filter(
-    (task, index, arr) => arr.findIndex((candidate) => candidate.id === task.id) === index
-  );
-  const chain = [...initialChain];
-  const visited = /* @__PURE__ */ new Set([changedTaskId, ...initialChain.map((t) => t.id)]);
-  const queue = [...initialChain];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const children = getChildren(current.id, allTasks);
-    for (const child of children) {
-      if (!visited.has(child.id)) {
-        visited.add(child.id);
-        chain.push(child);
-        queue.push(child);
-      }
-    }
-    const successors = allTypesSuccessorMap.get(current.id) ?? [];
-    for (const successor of successors) {
-      if (!visited.has(successor.id)) {
-        visited.add(successor.id);
-        chain.push(successor);
-        queue.push(successor);
-      }
-    }
-  }
-  return chain;
-}
-function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate) {
-  if (!task.dependencies) return [];
-  return task.dependencies.map((dep) => {
-    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
-    if (!predecessor) {
-      return { ...dep, lag: getDependencyLag(dep) };
-    }
-    const predecessorStart = new Date(predecessor.startDate);
-    const predecessorEnd = new Date(predecessor.endDate);
-    const nextLag = computeLagFromDates(
-      dep.type,
-      predecessorStart,
-      predecessorEnd,
-      newStartDate,
-      newEndDate,
-      businessDays,
-      weekendPredicate
-    );
-    return { ...dep, lag: nextLag };
-  });
-}
-function getAllDependencyEdges(tasks) {
-  const edges = [];
-  for (const task of tasks) {
-    if (task.dependencies) {
-      for (const dep of task.dependencies) {
-        edges.push({
-          predecessorId: dep.taskId,
-          successorId: task.id,
-          type: dep.type,
-          lag: getDependencyLag(dep)
-        });
-      }
-    }
-  }
-  return edges;
-}
-function getChildren(parentId, tasks) {
-  return tasks.filter((t) => t.parentId === parentId);
-}
-function isTaskParent(taskId, tasks) {
-  return tasks.some((t) => t.parentId === taskId);
-}
-function computeParentDates(parentId, tasks) {
-  const children = getChildren(parentId, tasks);
-  if (children.length === 0) {
-    const parent = tasks.find((t) => t.id === parentId);
-    const start = parent ? new Date(parent.startDate) : /* @__PURE__ */ new Date();
-    const end = parent ? new Date(parent.endDate) : /* @__PURE__ */ new Date();
-    return { startDate: start, endDate: end };
-  }
-  const startDates = children.map((c) => new Date(c.startDate));
-  const endDates = children.map((c) => new Date(c.endDate));
-  const minTime = Math.min(...startDates.map((d) => d.getTime()));
-  const maxTime = Math.max(...endDates.map((d) => d.getTime()));
-  return {
-    startDate: new Date(minTime),
-    endDate: new Date(maxTime)
-  };
-}
-function computeParentProgress(parentId, tasks) {
-  const children = getChildren(parentId, tasks);
-  if (children.length === 0) {
-    return 0;
-  }
-  const DAY_MS3 = 24 * 60 * 60 * 1e3;
-  let totalWeight = 0;
-  let weightedSum = 0;
-  for (const child of children) {
-    const start = new Date(child.startDate).getTime();
-    const end = new Date(child.endDate).getTime();
-    const duration = (end - start + DAY_MS3) / DAY_MS3;
-    const progress = child.progress ?? 0;
-    totalWeight += duration;
-    weightedSum += duration * progress;
-  }
-  if (totalWeight === 0) {
-    return 0;
-  }
-  return Math.round(weightedSum / totalWeight * 10) / 10;
-}
-function removeDependenciesBetweenTasks(taskId1, taskId2, tasks) {
-  return tasks.map((task) => {
-    if (task.id === taskId1 || task.id === taskId2) {
-      if (!task.dependencies) return task;
-      const otherTaskId = task.id === taskId1 ? taskId2 : taskId1;
-      const filteredDependencies = task.dependencies.filter((dep) => dep.taskId !== otherTaskId);
-      if (filteredDependencies.length === task.dependencies.length) {
-        return task;
-      }
-      return {
-        ...task,
-        dependencies: filteredDependencies.length > 0 ? filteredDependencies : void 0
-      };
-    }
-    return task;
-  });
-}
-function findParentId(taskId, tasks) {
-  const task = tasks.find((t) => t.id === taskId);
-  return task?.parentId;
-}
-function isAncestorTask(ancestorId, taskId, tasks) {
-  const taskById = new Map(tasks.map((task) => [task.id, task]));
-  const visited = /* @__PURE__ */ new Set();
-  let current = taskById.get(taskId);
-  while (current?.parentId) {
-    if (current.parentId === ancestorId) {
-      return true;
+          ...child,
+          startDate: newChildStart.toISOString().split("T")[0],
+          endDate: newChildEnd.toISOString().split("T")[0]
+        });
+        queue.push(child.id);
+      }
     }
-    if (visited.has(current.parentId)) {
-      return false;
+    for (const task of allTasks) {
+      if (visited.has(task.id) || !task.dependencies || task.locked) continue;
+      for (const dep of task.dependencies) {
+        if (dep.taskId !== currentId) continue;
+        const orig = taskById.get(task.id);
+        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));
+        let newSuccStart;
+        let newSuccEnd;
+        if (dep.type === "FS" || dep.type === "SS") {
+          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromStart(constraintDate, duration));
+        } else {
+          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromEnd(constraintDate, duration));
+        }
+        visited.add(task.id);
+        updatedDates.set(task.id, { start: newSuccStart, end: newSuccEnd });
+        result.push({
+          ...task,
+          startDate: newSuccStart.toISOString().split("T")[0],
+          endDate: newSuccEnd.toISOString().split("T")[0]
+        });
+        queue.push(task.id);
+        break;
+      }
     }
-    visited.add(current.parentId);
-    current = taskById.get(current.parentId);
   }
-  return false;
+  return result;
 }
-function areTasksHierarchicallyRelated(taskId1, taskId2, tasks) {
-  if (taskId1 === taskId2) {
-    return true;
+function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes) {
+  const allTypesSuccessorMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    allTypesSuccessorMap.set(task.id, []);
   }
-  return isAncestorTask(taskId1, taskId2, tasks) || isAncestorTask(taskId2, taskId1, tasks);
-}
-function getAllDescendants(parentId, tasks) {
-  const descendants = [];
-  const visited = /* @__PURE__ */ new Set();
-  function collectChildren(taskId) {
-    if (visited.has(taskId)) return;
-    visited.add(taskId);
-    const children = getChildren(taskId, tasks);
+  for (const task of allTasks) {
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      const list = allTypesSuccessorMap.get(dep.taskId) ?? [];
+      list.push(task);
+      allTypesSuccessorMap.set(dep.taskId, list);
+    }
+  }
+  const directChildren = getChildren(changedTaskId, allTasks);
+  const directSuccessors = getSuccessorChain(changedTaskId, allTasks, firstLevelLinkTypes);
+  const initialChain = [...directChildren, ...directSuccessors].filter(
+    (task, index, arr) => arr.findIndex((candidate) => candidate.id === task.id) === index
+  );
+  const chain = [...initialChain];
+  const visited = /* @__PURE__ */ new Set([changedTaskId, ...initialChain.map((t) => t.id)]);
+  const queue = [...initialChain];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const children = getChildren(current.id, allTasks);
     for (const child of children) {
-      descendants.push(child);
-      collectChildren(child.id);
+      if (!visited.has(child.id)) {
+        visited.add(child.id);
+        chain.push(child);
+        queue.push(child);
+      }
+    }
+    const successors = allTypesSuccessorMap.get(current.id) ?? [];
+    for (const successor of successors) {
+      if (!visited.has(successor.id)) {
+        visited.add(successor.id);
+        chain.push(successor);
+        queue.push(successor);
+      }
     }
   }
-  collectChildren(parentId);
-  return descendants;
+  return chain;
 }
-var DAY_MS = 24 * 60 * 60 * 1e3;
 function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays = false, weekendPredicate) {
   const taskById = new Map(allTasks.map((t) => [t.id, t]));
   const updatedDates = /* @__PURE__ */ new Map();
@@ -1309,6 +1306,105 @@ function reflowTasksOnModeSwitch(sourceTasks, toBusinessDays, weekendPredicate)
   return tasks;
 }
 
+// src/core/scheduling/validation.ts
+function buildAdjacencyList(tasks) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const successors = [];
+    for (const otherTask of tasks) {
+      if (otherTask.dependencies) {
+        for (const dep of otherTask.dependencies) {
+          if (dep.taskId === task.id) {
+            successors.push(otherTask.id);
+            break;
+          }
+        }
+      }
+    }
+    graph.set(task.id, successors);
+  }
+  return graph;
+}
+function detectCycles(tasks) {
+  const graph = buildAdjacencyList(tasks);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(taskId) {
+    if (visiting.has(taskId)) {
+      return true;
+    }
+    if (visited.has(taskId)) {
+      return false;
+    }
+    visiting.add(taskId);
+    path.push(taskId);
+    const successors = graph.get(taskId) || [];
+    for (const successor of successors) {
+      if (dfs(successor)) {
+        return true;
+      }
+    }
+    visiting.delete(taskId);
+    path.pop();
+    visited.add(taskId);
+    return false;
+  }
+  for (const task of tasks) {
+    if (dfs(task.id)) {
+      return { hasCycle: true, cyclePath: [...path] };
+    }
+  }
+  return { hasCycle: false };
+}
+function validateDependencies(tasks) {
+  const errors = [];
+  const taskIds = new Set(tasks.map((t) => t.id));
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        if (!taskIds.has(dep.taskId)) {
+          errors.push({
+            type: "missing-task",
+            taskId: task.id,
+            message: `Dependency references non-existent task: ${dep.taskId}`,
+            relatedTaskIds: [dep.taskId]
+          });
+        }
+      }
+    }
+  }
+  for (const task of tasks) {
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      if (!taskIds.has(dep.taskId)) {
+        continue;
+      }
+      if (areTasksHierarchicallyRelated(task.id, dep.taskId, tasks)) {
+        errors.push({
+          type: "constraint",
+          taskId: task.id,
+          message: `Dependencies between parent and child tasks are not allowed: ${dep.taskId} -> ${task.id}`,
+          relatedTaskIds: [dep.taskId, task.id]
+        });
+      }
+    }
+  }
+  const cycleResult = detectCycles(tasks);
+  if (cycleResult.hasCycle && cycleResult.cyclePath) {
+    errors.push({
+      type: "cycle",
+      taskId: cycleResult.cyclePath[0],
+      message: "Circular dependency detected",
+      relatedTaskIds: cycleResult.cyclePath
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
 // src/utils/hierarchyOrder.ts
 init_dateUtils();
 function flattenHierarchy(tasks) {
@@ -1790,7 +1886,6 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
 
 // src/hooks/useTaskDrag.ts
 var import_react2 = require("react");
-init_dateUtils();
 var globalActiveDrag = null;
 var globalRafId = null;
 function getDayOffsetFromMonthStart(date, monthStart) {
@@ -1798,62 +1893,6 @@ function getDayOffsetFromMonthStart(date, monthStart) {
     (Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) - Date.UTC(monthStart.getUTCFullYear(), monthStart.getUTCMonth(), monthStart.getUTCDate())) / (24 * 60 * 60 * 1e3)
   );
 }
-function resolveDraggedRange(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
-  const dayOffset = Math.round(left / dayWidth);
-  const rawStartDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + dayOffset
-  ));
-  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
-  const rawEndDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + rawEndOffset
-  ));
-  if (!(businessDays && weekendPredicate)) {
-    return { start: rawStartDate, end: rawEndDate };
-  }
-  if (mode === "move") {
-    const originalStart2 = new Date(task.startDate);
-    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
-    return moveTaskRange(
-      task.startDate,
-      task.endDate,
-      rawStartDate,
-      true,
-      weekendPredicate,
-      snapDirection2
-    );
-  }
-  if (mode === "resize-right") {
-    const fixedStart = new Date(task.startDate);
-    const originalEnd = new Date(task.endDate);
-    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
-    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
-    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
-    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
-  }
-  const fixedEnd = new Date(task.endDate);
-  const originalStart = new Date(task.startDate);
-  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
-  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
-  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
-  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
-}
-function clampDraggedRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
-  if (mode === "resize-right") {
-    return range;
-  }
-  return clampTaskRangeForIncomingFS(
-    task,
-    range.start,
-    range.end,
-    allTasks,
-    businessDays,
-    weekendPredicate
-  );
-}
 function completeDrag() {
   if (globalRafId !== null) {
     cancelAnimationFrame(globalRafId);
@@ -1911,9 +1950,9 @@ function handleGlobalMouseMove(e) {
     }
     const draggedTask = allTasks.find((t) => t.id === activeDrag.taskId);
     if (activeDrag.businessDays && activeDrag.weekendPredicate && draggedTask) {
-      const previewRange = clampDraggedRangeForIncomingFS(
+      const previewRange = clampDateRangeForIncomingFS(
         draggedTask,
-        resolveDraggedRange(
+        resolveDateRangeFromPixels(
           mode,
           newLeft,
           newWidth,
@@ -1933,9 +1972,9 @@ function handleGlobalMouseMove(e) {
       newLeft = Math.round(alignedStartDay * dayWidth);
       newWidth = Math.round((alignedEndDay - alignedStartDay + 1) * dayWidth);
     } else if (draggedTask) {
-      const previewRange = clampDraggedRangeForIncomingFS(
+      const previewRange = clampDateRangeForIncomingFS(
         draggedTask,
-        resolveDraggedRange(
+        resolveDateRangeFromPixels(
           mode,
           newLeft,
           newWidth,
@@ -1954,9 +1993,9 @@ function handleGlobalMouseMove(e) {
     if (!activeDrag.disableConstraints && activeDrag.onCascadeProgress) {
       const { dayWidth: dayWidth2, monthStart: mStart, taskId: dragId } = activeDrag;
       const originalDraggedTask = draggedTask ?? allTasks.find((t) => t.id === dragId);
-      const previewRange = originalDraggedTask ? clampDraggedRangeForIncomingFS(
+      const previewRange = originalDraggedTask ? clampDateRangeForIncomingFS(
         originalDraggedTask,
-        resolveDraggedRange(
+        resolveDateRangeFromPixels(
           mode,
           newLeft,
           newWidth,
@@ -2138,9 +2177,9 @@ var useTaskDrag = (options) => {
     const wasOwner = isOwnerRef.current;
     isOwnerRef.current = false;
     const currentTask = allTasks.find((t) => t.id === taskId);
-    const finalRange = currentTask ? clampDraggedRangeForIncomingFS(
+    const finalRange = currentTask ? clampDateRangeForIncomingFS(
       currentTask,
-      resolveDraggedRange(
+      resolveDateRangeFromPixels(
         finalMode,
         finalLeft,
         finalWidth,
@@ -3375,6 +3414,20 @@ var DatePicker = ({
     },
     [selectedDate, updateFromDate, businessDays, isWeekend3]
   );
+  const handleTriggerKeyDown = (0, import_react9.useCallback)((e) => {
+    if (disabled) return;
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      e.stopPropagation();
+      handleDayShift(1);
+      return;
+    }
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      e.stopPropagation();
+      handleDayShift(-1);
+    }
+  }, [disabled, handleDayShift]);
   const handleKeyDown = (0, import_react9.useCallback)((e) => {
     if (!dateInputRef.current) return;
     const { value: inputVal } = dateInputRef.current;
@@ -3482,6 +3535,7 @@ var DatePicker = ({
         type: "button",
         className: `gantt-datepicker-trigger${className ? ` ${className}` : ""}`,
         disabled,
+        onKeyDown: handleTriggerKeyDown,
         onClick: (e) => {
           e.stopPropagation();
         },
@@ -3868,7 +3922,7 @@ var DepChip = ({
         newStart = constraintDate;
         if (businessDays) {
           const businessDuration = getBusinessDaysCount(origStart, origEnd, weekendPredicate);
-          newEnd = /* @__PURE__ */ new Date(`${addBusinessDays(constraintDate, businessDuration, weekendPredicate)}T00:00:00.000Z`);
+          newEnd = addBusinessDays(constraintDate, businessDuration, weekendPredicate);
         } else {
           newEnd = new Date(constraintDate.getTime() + durationMs);
         }
@@ -3876,7 +3930,7 @@ var DepChip = ({
         newEnd = constraintDate;
         if (businessDays) {
           const businessDuration = getBusinessDaysCount(origStart, origEnd, weekendPredicate);
-          newStart = /* @__PURE__ */ new Date(`${subtractBusinessDays(constraintDate, businessDuration, weekendPredicate)}T00:00:00.000Z`);
+          newStart = subtractBusinessDays(constraintDate, businessDuration, weekendPredicate);
         } else {
           newStart = new Date(constraintDate.getTime() - durationMs);
         }
@@ -4144,7 +4198,7 @@ var TaskListRow = import_react10.default.memo(
     );
     const getEndDate = (0, import_react10.useCallback)(
       (start, duration) => {
-        return businessDays ? addBusinessDays(start, duration, weekendPredicate) : getEndDateFromDuration(start, duration);
+        return businessDays ? addBusinessDays(start, duration, weekendPredicate).toISOString().split("T")[0] : getEndDateFromDuration(start, duration);
       },
       [businessDays, weekendPredicate]
     );
@@ -6683,20 +6737,8 @@ function GanttChartInner(props, ref) {
       }
       return;
     }
-    const isParent = isTaskParent(updatedTask.id, tasks);
-    if (isParent) {
-      const { startDate: parentStart, endDate: parentEnd } = computeParentDates(updatedTask.id, tasks);
-      const parentWithRecalcDates = {
-        ...updatedTask,
-        startDate: parentStart.toISOString().split("T")[0],
-        endDate: parentEnd.toISOString().split("T")[0]
-      };
-      const cascadedTasks = disableConstraints ? [parentWithRecalcDates] : universalCascade(parentWithRecalcDates, parentStart, parentEnd, tasks, businessDays, isCustomWeekend);
-      onTasksChange?.(cascadedTasks);
-    } else {
-      const cascadedTasks = disableConstraints ? [updatedTask] : universalCascade(updatedTask, newStart, newEnd, tasks, businessDays, isCustomWeekend);
-      onTasksChange?.(cascadedTasks);
-    }
+    const cascadedTasks = disableConstraints ? [updatedTask] : universalCascade(updatedTask, newStart, newEnd, tasks, businessDays, isCustomWeekend);
+    onTasksChange?.(cascadedTasks);
   }, [tasks, onTasksChange, disableConstraints, editingTaskId, businessDays, isCustomWeekend]);
   const handleDelete = (0, import_react13.useCallback)((taskId) => {
     const toDelete = /* @__PURE__ */ new Set([taskId]);
@@ -7123,6 +7165,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
 0 && (module.exports = {
   Button,
   Calendar,
+  DAY_MS,
   DatePicker,
   DragGuideLines,
   GanttChart,
@@ -7168,6 +7211,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   formatDateRangeLabel,
   getAllDependencyEdges,
   getAllDescendants,
+  getBusinessDayOffset,
   getBusinessDaysCount,
   getChildren,
   getCursorForPosition,
@@ -7195,14 +7239,17 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   normalizeDependencyLag,
   normalizeHierarchyTasks,
   normalizeTaskDates,
+  normalizeUTCDate,
   not,
   or,
+  parseDateOnly,
   parseUTCDate,
   pixelsToDate,
   progressInRange,
   recalculateIncomingLags,
   reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks,
+  shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,
   useTaskDrag,