gantt-lib 0.136.1 → 0.138.0

package/dist/index.mjs

@@ -461,949 +461,1487 @@ function subtractBusinessDays2(endDate, businessDays, weekendPredicate) {
   return result.toISOString().split("T")[0];
 }
 
-// src/core/scheduling/dependencies.ts
-function normalizePredecessorDates(predecessor, parseDateFn) {
-  const predStart = parseDateFn(predecessor.startDate);
-  const predEnd = predecessor.type === "milestone" ? predStart : parseDateFn(predecessor.endDate);
-  return { predStart, predEnd };
-}
-function getDependencyLag(dep) {
-  return Number.isFinite(dep.lag) ? dep.lag : 0;
-}
-function normalizeTaskDependencyLags(task) {
-  return task;
-}
-function normalizeDependencyLag(linkType, lag, predecessorStart, predecessorEnd, businessDays = false, weekendPredicate, successorType) {
-  if (linkType !== "FS") {
-    return lag;
-  }
-  const predecessorDuration = getTaskDuration(
-    predecessorStart,
-    predecessorEnd,
-    businessDays,
-    weekendPredicate
+// src/utils/geometry.ts
+var getUTCDayDifference = (date1, date2) => {
+  const ms1 = Date.UTC(
+    date1.getUTCFullYear(),
+    date1.getUTCMonth(),
+    date1.getUTCDate()
   );
-  const minimumLag = successorType === "milestone" ? -Math.max(0, predecessorDuration - 1) : -predecessorDuration;
-  return Math.max(minimumLag, lag);
-}
-function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd, businessDays = false, weekendPredicate, successorType) {
-  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) - (successorType === "milestone" ? 0 : 1),
-          predStart,
-          predEnd,
-          businessDays,
-          weekendPredicate,
-          successorType
-        );
-      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;
+  const ms2 = Date.UTC(
+    date2.getUTCFullYear(),
+    date2.getUTCMonth(),
+    date2.getUTCDate()
+  );
+  return Math.round((ms1 - ms2) / (1e3 * 60 * 60 * 24));
+};
+var calculateTaskBar = (taskStartDate, taskEndDate, monthStart, dayWidth) => {
+  const startOffset = getUTCDayDifference(taskStartDate, monthStart);
+  const duration = getUTCDayDifference(taskEndDate, taskStartDate);
+  const left = Math.round(startOffset * 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 centerX = Math.round(dayLeft + dayWidth / 2);
+  return {
+    left: centerX - halfDiagonal,
+    right: centerX + halfDiagonal
+  };
+};
+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) {
+      const bounds2 = calculateMilestoneConnectionBounds(override.left, dayWidth, size);
+      return {
+        ...bounds2,
+        centerX: Math.round(override.left + dayWidth / 2)
+      };
     }
+    const bar2 = calculateTaskBar(startDate, startDate, monthStart, dayWidth);
+    const bounds = calculateMilestoneConnectionBounds(bar2.left, dayWidth, size);
+    return {
+      ...bounds,
+      centerX: Math.round(bar2.left + dayWidth / 2)
+    };
   }
-  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 - (successorType === "milestone" ? 0 : 1),
-        predStart,
-        predEnd,
-        businessDays,
-        weekendPredicate,
-        successorType
-      );
-    case "SS":
-      return businessOffset;
-    case "FF":
-      return businessOffset;
-    case "SF":
-      return businessOffset + 1;
+  if (override) {
+    return {
+      left: override.left,
+      right: override.left + override.width,
+      centerX: Math.round(override.left + override.width / 2)
+    };
   }
-}
-function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0, businessDays = false, weekendPredicate, successorType) {
-  const normalizedLag = normalizeDependencyLag(
-    linkType,
-    lag,
-    predecessorStart,
-    predecessorEnd,
-    businessDays,
-    weekendPredicate,
-    successorType
+  const bar = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
+  return {
+    left: bar.left,
+    right: bar.left + bar.width,
+    centerX: Math.round(bar.left + bar.width / 2)
+  };
+};
+var pixelsToDate = (pixels, monthStart, dayWidth) => {
+  const days = Math.round(pixels / dayWidth);
+  return new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + days
+  ));
+};
+var calculateGridWidth = (daysInMonth, dayWidth) => {
+  return Math.round(daysInMonth * dayWidth);
+};
+var MIN_EDGE_ZONE_PX = 8;
+var MIN_MOVE_ZONE_PX = 16;
+var detectEdgeZone = (clientX, taskBarElement, edgeZoneWidth = 12) => {
+  const rect = taskBarElement.getBoundingClientRect();
+  const relativeX = Math.round(clientX - rect.left);
+  const width = Math.round(rect.width);
+  const effectiveZone = Math.max(
+    MIN_EDGE_ZONE_PX,
+    Math.min(edgeZoneWidth, (width - MIN_MOVE_ZONE_PX) / 2)
   );
-  if (!businessDays || !weekendPredicate) {
-    switch (linkType) {
-      case "FS":
-        return new Date(predecessorEnd.getTime() + (normalizedLag + (successorType === "milestone" ? 0 : 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 anchorDate = linkType === "FS" || linkType === "FF" ? predecessorEnd : predecessorStart;
-  let offset;
-  switch (linkType) {
-    case "FS":
-      offset = normalizedLag + (successorType === "milestone" ? 0 : 1);
-      break;
-    case "SS":
-      offset = normalizedLag;
-      break;
-    case "FF":
-      offset = normalizedLag;
-      break;
-    case "SF":
-      offset = normalizedLag - 1;
-      break;
+  if (relativeX >= 0 && relativeX <= effectiveZone) {
+    return "left";
   }
-  return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
-}
-
-// src/core/scheduling/criticalPath.ts
-function computeCriticalPath(tasks, options = {}) {
-  const { businessDays = false, weekendPredicate } = options;
-  const taskById = new Map(tasks.map((task) => [task.id, task]));
-  const childIds = /* @__PURE__ */ new Set();
-  for (const task of tasks) {
-    if (task.parentId) childIds.add(task.parentId);
+  if (relativeX >= width - effectiveZone && relativeX <= width) {
+    return "right";
   }
-  const leafTasks = tasks.filter((task) => !childIds.has(task.id));
-  const leafIds = new Set(leafTasks.map((task) => task.id));
-  const leafIdsByAncestor = /* @__PURE__ */ new Map();
-  for (const leaf of leafTasks) {
-    let ancestor = leaf.parentId;
-    while (ancestor) {
-      const set = leafIdsByAncestor.get(ancestor) ?? /* @__PURE__ */ new Set();
-      set.add(leaf.id);
-      leafIdsByAncestor.set(ancestor, set);
-      ancestor = taskById.get(ancestor)?.parentId;
-    }
+  return "move";
+};
+var getCursorForPosition = (position) => {
+  switch (position) {
+    case "left":
+    case "right":
+      return "ew-resize";
+    case "move":
+      return "grab";
+    default:
+      return "default";
   }
-  const durationOf = (task) => getTaskDuration(task.startDate, task.endDate, businessDays, weekendPredicate);
-  const projectStartDate = leafTasks.reduce((earliest, task) => {
-    const taskStart = parseDateOnly(task.startDate);
-    return taskStart.getTime() < earliest.getTime() ? taskStart : earliest;
-  }, parseDateOnly(leafTasks[0]?.startDate ?? /* @__PURE__ */ new Date()));
-  const offsetFromProjectStart = (date) => {
-    const targetDate = parseDateOnly(date);
-    if (businessDays && weekendPredicate) {
-      return getBusinessDayOffset(projectStartDate, targetDate, weekendPredicate);
-    }
-    return Math.round((targetDate.getTime() - projectStartDate.getTime()) / DAY_MS);
-  };
-  const scheduledStart = /* @__PURE__ */ new Map();
-  for (const leaf of leafTasks) {
-    scheduledStart.set(leaf.id, offsetFromProjectStart(leaf.startDate));
+};
+var calculateGridLines = (dateRange, dayWidth) => {
+  const lines = [];
+  for (let i = 0; i < dateRange.length; i++) {
+    const date = dateRange[i];
+    const x = Math.round(i * dayWidth);
+    const isMonthStart = i === 0 ? false : date.getUTCDate() === 1;
+    const isWeekStart = date.getUTCDay() === 1;
+    lines.push({ x, isMonthStart, isWeekStart });
   }
-  const succByPred = /* @__PURE__ */ new Map();
-  const predBySucc = /* @__PURE__ */ new Map();
-  const seenEdges = /* @__PURE__ */ new Set();
-  const addEdge = (predecessorId, succId, lag, type) => {
-    const edgeKey = `${predecessorId}|${succId}|${type}`;
-    if (seenEdges.has(edgeKey)) return;
-    seenEdges.add(edgeKey);
-    const outEdges = succByPred.get(predecessorId) ?? [];
-    outEdges.push({ succId, lag, type });
-    succByPred.set(predecessorId, outEdges);
-    const inEdges = predBySucc.get(succId) ?? [];
-    inEdges.push({ predId: predecessorId, lag, type });
-    predBySucc.set(succId, inEdges);
-  };
-  for (const succ of leafTasks) {
-    for (const dep of succ.dependencies ?? []) {
-      const lag = getDependencyLag(dep);
-      if (leafIds.has(dep.taskId)) {
-        addEdge(dep.taskId, succ.id, lag, dep.type);
-        continue;
-      }
-      const descendants = leafIdsByAncestor.get(dep.taskId);
-      if (!descendants || descendants.size === 0) continue;
-      for (const leafId of descendants) {
-        if (leafId === succ.id) continue;
-        addEdge(leafId, succ.id, lag, dep.type);
-      }
-    }
+  if (dateRange.length > 0) {
+    lines.push({
+      x: Math.round(dateRange.length * dayWidth),
+      isMonthStart: false,
+      isWeekStart: false
+    });
   }
-  const indegree = /* @__PURE__ */ new Map();
-  for (const leaf of leafTasks) indegree.set(leaf.id, 0);
-  for (const edges of succByPred.values()) {
-    for (const { succId } of edges) {
-      indegree.set(succId, (indegree.get(succId) ?? 0) + 1);
+  return lines;
+};
+var calculateWeekendBlocks = (dateRange, dayWidth, isCustomWeekend) => {
+  const blocks = [];
+  let inWeekend = false;
+  let weekendStartIndex = -1;
+  for (let i = 0; i < dateRange.length; i++) {
+    const date = dateRange[i];
+    const isWeekend3 = isCustomWeekend ? isCustomWeekend(date) : date.getUTCDay() === 0 || date.getUTCDay() === 6;
+    if (isWeekend3 && !inWeekend) {
+      inWeekend = true;
+      weekendStartIndex = i;
+    } else if (!isWeekend3 && inWeekend) {
+      inWeekend = false;
+      const left = Math.round(weekendStartIndex * dayWidth);
+      const width = Math.round((i - weekendStartIndex) * dayWidth);
+      blocks.push({ left, width });
     }
   }
-  const order = [];
-  const enqueued = /* @__PURE__ */ new Set();
-  const queue = leafTasks.filter((leaf) => (indegree.get(leaf.id) ?? 0) === 0).map((leaf) => leaf.id);
-  for (const id of queue) enqueued.add(id);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    order.push(current);
-    for (const { succId } of succByPred.get(current) ?? []) {
-      const next = (indegree.get(succId) ?? 0) - 1;
-      indegree.set(succId, next);
-      if (next === 0 && !enqueued.has(succId)) {
-        enqueued.add(succId);
-        queue.push(succId);
-      }
-    }
+  if (inWeekend && weekendStartIndex >= 0) {
+    const left = Math.round(weekendStartIndex * dayWidth);
+    const width = Math.round((dateRange.length - weekendStartIndex) * dayWidth);
+    blocks.push({ left, width });
   }
-  const projectFinish = Math.max(
-    0,
-    ...leafTasks.map((leaf) => (scheduledStart.get(leaf.id) ?? 0) + durationOf(leaf))
-  );
-  const LF = /* @__PURE__ */ new Map();
-  const LS = /* @__PURE__ */ new Map();
-  for (const leaf of leafTasks) LF.set(leaf.id, projectFinish);
-  for (let i = order.length - 1; i >= 0; i--) {
-    const id = order[i];
-    const task = taskById.get(id);
-    const durPred = durationOf(task);
-    const outEdges = succByPred.get(id) ?? [];
-    let lf = projectFinish;
-    if (outEdges.length > 0) {
-      const candidates = outEdges.map(({ succId, lag, type }) => {
-        const succLs = LS.get(succId) ?? projectFinish;
-        const durSucc = durationOf(taskById.get(succId));
-        switch (type) {
-          case "FS":
-            return succLs - lag;
-          case "SS":
-            return succLs - lag + durPred;
-          case "FF":
-            return succLs + durSucc - lag;
-          case "SF":
-            return succLs + durSucc - lag + durPred;
-          default:
-            return projectFinish;
-        }
-      });
-      lf = Math.min(projectFinish, ...candidates);
+  return blocks;
+};
+var calculateBezierPath = (from, to) => {
+  const verticalDistance = Math.abs(to.y - from.y);
+  const cpOffset = Math.max(verticalDistance * 0.5, 20);
+  if (from.y === to.y) {
+    const arcHeight = 20;
+    const midX = (from.x + to.x) / 2;
+    return `M ${from.x} ${from.y} Q ${midX} ${from.y - arcHeight} ${to.x} ${to.y}`;
+  }
+  const cp1x = from.x;
+  const cp1y = from.y + (to.y > from.y ? cpOffset : -cpOffset);
+  const cp2x = to.x;
+  const cp2y = to.y - (to.y > from.y ? cpOffset : -cpOffset);
+  return `M ${Math.round(from.x)} ${Math.round(from.y)} C ${Math.round(cp1x)} ${Math.round(cp1y)}, ${Math.round(cp2x)} ${Math.round(cp2y)}, ${Math.round(to.x)} ${Math.round(to.y)}`;
+};
+var calculateDependencyPath = (from, to, arrivesFromRight) => {
+  const fx = Math.round(from.x);
+  const fy = Math.round(from.y);
+  const tx = Math.round(to.x);
+  const ty = Math.round(to.y);
+  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;
+  if (arrivesFromRight) {
+    const goingRight = tx >= fx;
+    const dirX = goingRight ? 1 : -1;
+    if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
+      return [
+        `M ${fx} ${fy}`,
+        `H ${tx - dirX * C}`,
+        `L ${tx} ${fy + dirY * C}`,
+        `V ${ty}`
+      ].join(" ");
     }
-    LF.set(id, lf);
-    LS.set(id, lf - durPred);
+    return `M ${fx} ${fy} H ${tx} V ${ty}`;
+  } else {
+    const goingRight = tx >= fx;
+    const dirX = goingRight ? 1 : -1;
+    if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
+      return [
+        `M ${fx} ${fy}`,
+        `H ${tx - dirX * C}`,
+        `L ${tx} ${fy + dirY * C}`,
+        `V ${ty}`
+      ].join(" ");
+    }
+    return `M ${fx} ${fy} H ${tx} V ${ty}`;
   }
-  const critical = /* @__PURE__ */ new Set();
-  const ordered = new Set(order);
-  for (const leaf of leafTasks) {
-    if (!ordered.has(leaf.id)) continue;
-    const hasGraphEdge = (succByPred.get(leaf.id)?.length ?? 0) > 0 || (predBySucc.get(leaf.id)?.length ?? 0) > 0;
-    if (!hasGraphEdge && (leaf.dependencies?.length ?? 0) > 0) continue;
-    const es = scheduledStart.get(leaf.id) ?? 0;
-    const ls = LS.get(leaf.id) ?? 0;
-    if (ls - es <= 0) critical.add(leaf.id);
+};
+var calculateWeekGridLines = (dateRange, dayWidth) => {
+  const blocks = getWeekBlocks(dateRange);
+  const lines = [];
+  let currentDayIndex = 0;
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    currentDayIndex += block.days;
+    const blockEndMonth = dateRange[currentDayIndex - 1];
+    const nextBlockMonth = currentDayIndex < dateRange.length ? dateRange[currentDayIndex] : null;
+    const isMonthBoundary = nextBlockMonth && blockEndMonth.getUTCMonth() !== nextBlockMonth.getUTCMonth();
+    lines.push({
+      x: Math.round(currentDayIndex * dayWidth),
+      isMonthStart: isMonthBoundary || false
+    });
   }
-  return critical;
-}
-function extendCriticalIdsToParents(criticalLeafIds, tasks) {
-  const result = new Set(criticalLeafIds);
-  const parentByChild = /* @__PURE__ */ new Map();
-  for (const task of tasks) {
-    if (task.parentId) parentByChild.set(task.id, task.parentId);
+  if (lines.length > 0 && lines[lines.length - 1].x === Math.round(dateRange.length * dayWidth)) {
+    lines.pop();
   }
-  const stack = Array.from(criticalLeafIds);
-  while (stack.length > 0) {
-    const id = stack.pop();
-    const parentId = parentByChild.get(id);
-    if (parentId && !result.has(parentId)) {
-      result.add(parentId);
-      stack.push(parentId);
+  return lines;
+};
+var calculateMonthGridLines = (dateRange, dayWidth) => {
+  const lines = [];
+  for (let i = 1; i < dateRange.length; i++) {
+    const date = dateRange[i];
+    if (date.getUTCDate() === 1) {
+      const x = Math.round(i * dayWidth);
+      const isYearBoundary = date.getUTCMonth() === 0;
+      lines.push({ x, isMonthStart: isYearBoundary });
     }
   }
-  return result;
-}
+  return lines;
+};
+var calculateOrthogonalPath = (from, to) => {
+  const fx = Math.round(from.x);
+  const fy = Math.round(from.y);
+  const tx = Math.round(to.x);
+  const ty = Math.round(to.y);
+  if (fy === ty) {
+    return `M ${fx} ${fy} H ${tx}`;
+  }
+  const C = 2;
+  const goingDown = ty > fy;
+  const goingRight = tx >= fx;
+  const dirY = goingDown ? 1 : -1;
+  const dirX = goingRight ? 1 : -1;
+  if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
+    return [
+      `M ${fx} ${fy}`,
+      `H ${tx - dirX * C}`,
+      `L ${tx} ${fy + dirY * C}`,
+      `V ${ty}`
+    ].join(" ");
+  }
+  return `M ${fx} ${fy} H ${tx} V ${ty}`;
+};
 
-// src/core/scheduling/commands.ts
-function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
-  const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
-  if (businessDays && weekendPredicate) {
+// src/utils/activities.ts
+var ACTIVITY_LANE_STEP = 28;
+var ACTIVITY_LANE_BAR_HEIGHT = 24;
+var ACTIVITY_LANES_PADDING = 2;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+function packIntervals(intervals) {
+  const sorted = [...intervals].sort((a, b) => a.start - b.start);
+  const laneEnds = [];
+  return sorted.map((item) => {
+    let lane = 0;
+    while (lane < laneEnds.length && item.start < laneEnds[lane]) {
+      lane += 1;
+    }
+    laneEnds[lane] = item.end;
+    return { ...item, lane };
+  });
+}
+function computeActivityLanes(activities, monthStart, dayWidth) {
+  if (activities.length === 0) {
+    return { segments: [], laneCount: 0 };
+  }
+  const packed = packIntervals(activities.map((activity) => {
+    const bar = calculateTaskBar(parseUTCDate(activity.startDate), parseUTCDate(activity.endDate), monthStart, dayWidth);
     return {
-      start: normalizedStart,
-      end: parseDateOnly(addBusinessDays(normalizedStart, duration, weekendPredicate))
+      id: activity.id,
+      name: activity.name,
+      color: activity.color,
+      lag: activity.lag,
+      progress: activity.progress,
+      start: bar.left,
+      end: bar.left + bar.width,
+      left: bar.left,
+      width: bar.width
     };
-  }
-  const DAY_MS6 = 24 * 60 * 60 * 1e3;
+  }));
   return {
-    start: normalizedStart,
-    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS6)
+    segments: packed.map(({ id, name, color, lag, progress, lane, left, width }) => ({ id, name, color, lag, progress, lane, left, width })),
+    laneCount: Math.max(...packed.map((item) => item.lane + 1))
   };
 }
-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_MS6 = 24 * 60 * 60 * 1e3;
+function activityBounds(activities) {
+  if (!activities || activities.length === 0) return null;
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  for (const activity of activities) {
+    const start = parseUTCDate(activity.startDate).getTime();
+    const end = parseUTCDate(activity.endDate).getTime();
+    if (start < min) min = start;
+    if (end > max) max = end;
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return null;
+  const toIso = (ms) => new Date(ms).toISOString().slice(0, 10);
+  return { startDate: toIso(min), endDate: toIso(max) };
+}
+function activityLanesExtraHeight(laneCount) {
+  if (laneCount <= 1) return 0;
+  return laneCount * ACTIVITY_LANE_STEP + ACTIVITY_LANES_PADDING * 2;
+}
+function activitySpanMs(activity) {
   return {
-    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS6),
-    end: normalizedEnd
+    start: parseUTCDate(activity.startDate).getTime(),
+    end: parseUTCDate(activity.endDate).getTime() + DAY_MS2
   };
 }
-function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays = false, weekendPredicate, snapDirection = 1) {
-  return buildTaskRangeFromStart(
-    proposedStart,
-    getTaskDuration(originalStart, originalEnd, businessDays, weekendPredicate),
-    businessDays,
-    weekendPredicate,
-    snapDirection
-  );
+function shiftActivityDate(value, days) {
+  const shifted = new Date(parseUTCDate(value).getTime() + days * DAY_MS2);
+  return typeof value === "string" ? shifted.toISOString().slice(0, 10) : shifted;
 }
-function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate, taskById) {
-  if (!task.dependencies?.length) {
-    return { start: proposedStart, end: proposedEnd };
-  }
-  let minAllowedStart = null;
-  for (const dep of task.dependencies) {
-    if (dep.type !== "FS") {
-      continue;
+var CHAIN_KEY_SEPARATOR = "\0";
+var chainKey = (taskId, activityId) => `${taskId}${CHAIN_KEY_SEPARATOR}${activityId}`;
+var toDayNumber = (value) => Math.round(parseUTCDate(value).getTime() / DAY_MS2);
+function buildChainGraph(orderedTasks) {
+  const successors = /* @__PURE__ */ new Map();
+  const predecessors = /* @__PURE__ */ new Map();
+  const info = /* @__PURE__ */ new Map();
+  const link = (from, to, lag) => {
+    const list = successors.get(from);
+    if (list) {
+      if (!list.some((edge) => edge.key === to)) list.push({ key: to, lag });
+    } else {
+      successors.set(from, [{ key: to, lag }]);
     }
-    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
-    if (!predecessor) {
-      continue;
+    const back = predecessors.get(to);
+    if (back) {
+      if (!back.some((edge) => edge.key === from)) back.push({ key: from, lag });
+    } else {
+      predecessors.set(to, [{ key: from, lag }]);
     }
-    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
-    const predecessorDuration = getTaskDuration(
-      predecessorStart,
-      predecessorEnd,
-      businessDays,
-      weekendPredicate
-    );
-    const candidateMinStart = calculateSuccessorDate(
-      predecessorStart,
-      predecessorEnd,
-      "FS",
-      -predecessorDuration,
-      businessDays,
-      weekendPredicate,
-      task.type
-    );
-    if (!minAllowedStart || candidateMinStart.getTime() > minAllowedStart.getTime()) {
-      minAllowedStart = candidateMinStart;
+  };
+  const flagged = orderedTasks.filter((task) => Boolean(task.activityChain) && Array.isArray(task.activities) && task.activities.length > 0);
+  flagged.forEach((task, floorIdx) => {
+    task.activities.forEach((activity, workIdx) => {
+      info.set(chainKey(task.id, activity.id), {
+        taskId: task.id,
+        activityId: activity.id,
+        startDay: toDayNumber(activity.startDate),
+        durationDays: Math.max(1, toDayNumber(activity.endDate) - toDayNumber(activity.startDate) + 1),
+        floorIdx,
+        workIdx
+      });
+    });
+    for (let i = 0; i < task.activities.length - 1; i += 1) {
+      link(chainKey(task.id, task.activities[i].id), chainKey(task.id, task.activities[i + 1].id), task.activities[i + 1].lag ?? 0);
+    }
+  });
+  for (let f = 0; f < flagged.length - 1; f += 1) {
+    const current = flagged[f];
+    const next = flagged[f + 1];
+    if (current.parentId !== next.parentId) continue;
+    for (const activity of current.activities) {
+      const twin = next.activities.find((candidate) => candidate.id === activity.id || candidate.name === activity.name);
+      if (twin) link(chainKey(current.id, activity.id), chainKey(next.id, twin.id), 0);
     }
   }
-  if (!minAllowedStart || proposedStart.getTime() >= minAllowedStart.getTime()) {
-    return { start: proposedStart, end: proposedEnd };
+  return { successors, predecessors, info };
+}
+function collectDownstream(graph, startKey) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...(graph.successors.get(startKey) ?? []).map((edge) => edge.key)];
+  while (queue.length > 0) {
+    const key = queue.shift();
+    if (visited.has(key)) continue;
+    visited.add(key);
+    queue.push(...(graph.successors.get(key) ?? []).map((edge) => edge.key));
   }
-  return buildTaskRangeFromStart(
-    minAllowedStart,
-    getTaskDuration(proposedStart, proposedEnd, businessDays, weekendPredicate),
-    businessDays,
-    weekendPredicate
-  );
+  return visited;
 }
-function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate, taskById) {
-  if (!task.dependencies) return [];
-  return task.dependencies.map((dep) => {
-    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
-    if (!predecessor) {
-      return { ...dep, lag: getDependencyLag(dep) };
+function shiftsFromDeltas(orderedTasks, deltasByTask) {
+  const shifts = [];
+  for (const task of orderedTasks) {
+    const deltas = deltasByTask.get(task.id);
+    if (!deltas || deltas.size === 0) continue;
+    shifts.push({
+      taskId: task.id,
+      shiftedIds: new Set(deltas.keys()),
+      deltas,
+      activities: (task.activities ?? []).map((activity) => deltas.has(activity.id) ? {
+        ...activity,
+        startDate: shiftActivityDate(activity.startDate, deltas.get(activity.id)),
+        endDate: shiftActivityDate(activity.endDate, deltas.get(activity.id))
+      } : activity)
+    });
+  }
+  return shifts;
+}
+function shiftActivityChain(orderedTasks, draggedTaskId, draggedActivityId, deltaDays) {
+  if (deltaDays === 0) return [];
+  const graph = buildChainGraph(orderedTasks);
+  const shifted = collectDownstream(graph, chainKey(draggedTaskId, draggedActivityId));
+  if (shifted.size === 0) return [];
+  const deltasByTask = /* @__PURE__ */ new Map();
+  for (const key of shifted) {
+    const node = graph.info.get(key);
+    const set = deltasByTask.get(node.taskId);
+    if (set) set.set(node.activityId, deltaDays);
+    else deltasByTask.set(node.taskId, /* @__PURE__ */ new Map([[node.activityId, deltaDays]]));
+  }
+  return shiftsFromDeltas(orderedTasks, deltasByTask);
+}
+function activityStartConstraint(orderedTasks, taskId, activityId) {
+  const graph = buildChainGraph(orderedTasks);
+  const key = chainKey(taskId, activityId);
+  const node = graph.info.get(key);
+  if (!node) return null;
+  const candidates = [];
+  let minStart = Number.NEGATIVE_INFINITY;
+  for (const pred of graph.predecessors.get(key) ?? []) {
+    const predNode = graph.info.get(pred.key);
+    if (!predNode) continue;
+    const min = predNode.startDay + predNode.durationDays + pred.lag;
+    candidates.push({ taskId: predNode.taskId, activityId: predNode.activityId, min, lag: pred.lag });
+    if (min > minStart) minStart = min;
+  }
+  if (!Number.isFinite(minStart)) return null;
+  const blockers = candidates.filter((candidate) => candidate.min === minStart);
+  return {
+    minStartDay: minStart,
+    minStartDelta: minStart - node.startDay,
+    blockers: blockers.map(({ taskId: blockerTaskId, activityId: blockerActivityId }) => ({
+      taskId: blockerTaskId,
+      activityId: blockerActivityId
+    })),
+    lag: Math.max(0, ...blockers.map((blocker) => blocker.lag))
+  };
+}
+function activityChainMinStartDelta(orderedTasks, taskId, activityId) {
+  return activityStartConstraint(orderedTasks, taskId, activityId)?.minStartDelta ?? null;
+}
+function pushActivityChain(orderedTasks, draggedTaskId, draggedActivityId, requestedDeltaDays) {
+  const graph = buildChainGraph(orderedTasks);
+  const draggedKey = chainKey(draggedTaskId, draggedActivityId);
+  if (!graph.info.has(draggedKey)) {
+    return { shifts: [], draggedDeltaDays: requestedDeltaDays };
+  }
+  const downstream = collectDownstream(graph, draggedKey);
+  if (downstream.size === 0) {
+    return { shifts: [], draggedDeltaDays: requestedDeltaDays };
+  }
+  const newStart = /* @__PURE__ */ new Map();
+  const dragged = graph.info.get(draggedKey);
+  newStart.set(draggedKey, dragged.startDay + requestedDeltaDays);
+  const endOfDay = (key) => {
+    const node = graph.info.get(key);
+    return (newStart.get(key) ?? node.startDay) + node.durationDays;
+  };
+  const order = [...downstream].map((key) => ({ key, node: graph.info.get(key) })).sort((a, b) => a.node.workIdx - b.node.workIdx || a.node.floorIdx - b.node.floorIdx);
+  for (const { key, node } of order) {
+    let earliest = Number.NEGATIVE_INFINITY;
+    let oldEarliest = Number.NEGATIVE_INFINITY;
+    for (const pred of graph.predecessors.get(key) ?? []) {
+      const predNode = graph.info.get(pred.key);
+      earliest = Math.max(earliest, endOfDay(pred.key) + pred.lag);
+      oldEarliest = Math.max(oldEarliest, predNode.startDay + predNode.durationDays + pred.lag);
+    }
+    let nextStart;
+    if (earliest > node.startDay) {
+      nextStart = earliest;
+    } else if (earliest < oldEarliest) {
+      nextStart = earliest;
+    } else {
+      nextStart = node.startDay;
     }
-    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,
-      predecessorEnd,
-      newStartDate,
-      newEndDate,
-      businessDays,
-      weekendPredicate,
-      task.type
-    );
-    return { ...dep, lag: nextLag };
-  });
+    newStart.set(key, nextStart);
+  }
+  const deltasByTask = /* @__PURE__ */ new Map();
+  for (const key of downstream) {
+    const node = graph.info.get(key);
+    const delta = (newStart.get(key) ?? node.startDay) - node.startDay;
+    if (delta === 0) continue;
+    const set = deltasByTask.get(node.taskId);
+    if (set) set.set(node.activityId, delta);
+    else deltasByTask.set(node.taskId, /* @__PURE__ */ new Map([[node.activityId, delta]]));
+  }
+  return { shifts: shiftsFromDeltas(orderedTasks, deltasByTask), draggedDeltaDays: requestedDeltaDays };
 }
 
-// src/core/scheduling/cascade.ts
-function parseCascadeDateInput(date) {
-  if (date instanceof Date) {
-    return normalizeUTCDate(date);
+// src/core/scheduling/dependencies.ts
+function normalizePredecessorDates(predecessor, parseDateFn) {
+  const predStart = parseDateFn(predecessor.startDate);
+  const predEnd = predecessor.type === "milestone" ? predStart : parseDateFn(predecessor.endDate);
+  return { predStart, predEnd };
+}
+function getDependencyLag(dep) {
+  return Number.isFinite(dep.lag) ? dep.lag : 0;
+}
+function normalizeTaskDependencyLags(task) {
+  return task;
+}
+function normalizeDependencyLag(linkType, lag, predecessorStart, predecessorEnd, businessDays = false, weekendPredicate, successorType) {
+  if (linkType !== "FS") {
+    return lag;
   }
-  return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
+  const predecessorDuration = getTaskDuration(
+    predecessorStart,
+    predecessorEnd,
+    businessDays,
+    weekendPredicate
+  );
+  const minimumLag = successorType === "milestone" ? -Math.max(0, predecessorDuration - 1) : -predecessorDuration;
+  return Math.max(minimumLag, lag);
 }
-function createCascadeContext(allTasks) {
-  const childrenByParentId = /* @__PURE__ */ new Map();
-  const dependentsByPredecessorId = /* @__PURE__ */ new Map();
-  const taskById = /* @__PURE__ */ new Map();
-  for (const task of allTasks) {
-    taskById.set(task.id, task);
-    if (task.parentId) {
-      const children = childrenByParentId.get(task.parentId) ?? [];
-      children.push(task);
-      childrenByParentId.set(task.parentId, children);
+function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd, businessDays = false, weekendPredicate, successorType) {
+  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) - (successorType === "milestone" ? 0 : 1),
+          predStart,
+          predEnd,
+          businessDays,
+          weekendPredicate,
+          successorType
+        );
+      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;
     }
-    if (!task.dependencies) continue;
-    task.dependencies.forEach((dependency, dependencyIndex) => {
-      const dependents = dependentsByPredecessorId.get(dependency.taskId) ?? [];
-      dependents.push({ task, dependencyIndex });
-      dependentsByPredecessorId.set(dependency.taskId, dependents);
-    });
   }
-  return { childrenByParentId, dependentsByPredecessorId, taskById };
+  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 - (successorType === "milestone" ? 0 : 1),
+        predStart,
+        predEnd,
+        businessDays,
+        weekendPredicate,
+        successorType
+      );
+    case "SS":
+      return businessOffset;
+    case "FF":
+      return businessOffset;
+    case "SF":
+      return businessOffset + 1;
+  }
 }
-function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
-  const { dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [draggedTaskId];
-  const chain = [];
-  visited.add(draggedTaskId);
-  while (queue.length > 0) {
-    const current = queue.shift();
-    const successors = dependentsByPredecessorId.get(current) ?? [];
-    for (const { task } of successors) {
-      if (!linkTypes.includes(task.dependencies?.find((dependency) => dependency.taskId === current)?.type ?? "FS")) {
-        continue;
-      }
-      const sid = task.id;
-      if (!visited.has(sid)) {
-        visited.add(sid);
-        const successorTask = taskById.get(sid);
-        if (successorTask) {
-          chain.push(successorTask);
-          queue.push(sid);
-        }
-      }
+function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0, businessDays = false, weekendPredicate, successorType) {
+  const normalizedLag = normalizeDependencyLag(
+    linkType,
+    lag,
+    predecessorStart,
+    predecessorEnd,
+    businessDays,
+    weekendPredicate,
+    successorType
+  );
+  if (!businessDays || !weekendPredicate) {
+    switch (linkType) {
+      case "FS":
+        return new Date(predecessorEnd.getTime() + (normalizedLag + (successorType === "milestone" ? 0 : 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);
     }
   }
-  return chain;
+  const anchorDate = linkType === "FS" || linkType === "FF" ? predecessorEnd : predecessorStart;
+  let offset;
+  switch (linkType) {
+    case "FS":
+      offset = normalizedLag + (successorType === "milestone" ? 0 : 1);
+      break;
+    case "SS":
+      offset = normalizedLag;
+      break;
+    case "FF":
+      offset = normalizedLag;
+      break;
+    case "SF":
+      offset = normalizedLag - 1;
+      break;
+  }
+  return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
 }
-function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascade = false) {
-  const { childrenByParentId, dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
-  const updatedDates = /* @__PURE__ */ new Map();
-  updatedDates.set(movedTaskId, { start: newStart, end: newEnd });
-  const result = [];
-  const queue = [movedTaskId];
-  const visited = /* @__PURE__ */ new Set([movedTaskId]);
-  while (queue.length > 0) {
-    const currentId = queue.shift();
-    const { start: predStart, end: predEnd } = updatedDates.get(currentId);
-    if (!skipChildCascade) {
-      const children = childrenByParentId.get(currentId) ?? [];
-      for (const child of children) {
-        if (visited.has(child.id) || child.locked) continue;
-        const origStart = new Date(child.startDate);
-        const origEnd = new Date(child.endDate);
-        const durationMs = origEnd.getTime() - origStart.getTime();
-        const parentOrig = taskById.get(currentId);
-        const parentOrigStart = new Date(parentOrig.startDate);
-        const parentOrigEnd = new Date(parentOrig.endDate);
-        const parentStartDelta = predStart.getTime() - parentOrigStart.getTime();
-        const parentEndDelta = predEnd.getTime() - parentOrigEnd.getTime();
-        const newChildStart = new Date(origStart.getTime() + parentStartDelta);
-        const newChildEnd = new Date(origEnd.getTime() + parentEndDelta);
-        visited.add(child.id);
-        updatedDates.set(child.id, { start: newChildStart, end: newChildEnd });
-        result.push(normalizeTaskDependencyLags({
-          ...child,
-          startDate: newChildStart.toISOString().split("T")[0],
-          endDate: newChildEnd.toISOString().split("T")[0]
-        }));
-        queue.push(child.id);
-      }
+
+// src/core/scheduling/criticalPath.ts
+function computeCriticalPath(tasks, options = {}) {
+  const { businessDays = false, weekendPredicate } = options;
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const childIds = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    if (task.parentId) childIds.add(task.parentId);
+  }
+  const leafTasks = tasks.filter((task) => !childIds.has(task.id));
+  const leafIds = new Set(leafTasks.map((task) => task.id));
+  const leafIdsByAncestor = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) {
+    let ancestor = leaf.parentId;
+    while (ancestor) {
+      const set = leafIdsByAncestor.get(ancestor) ?? /* @__PURE__ */ new Set();
+      set.add(leaf.id);
+      leafIdsByAncestor.set(ancestor, set);
+      ancestor = taskById.get(ancestor)?.parentId;
     }
-    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
-    for (const { task, dependencyIndex } of dependents) {
-      if (visited.has(task.id) || !task.dependencies || task.locked) continue;
-      const dep = task.dependencies[dependencyIndex];
-      if (!dep) 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 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),
-        false,
-        void 0,
-        task.type
-      );
-      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));
+  }
+  const durationOf = (task) => getTaskDuration(task.startDate, task.endDate, businessDays, weekendPredicate);
+  const projectStartDate = leafTasks.reduce((earliest, task) => {
+    const taskStart = parseDateOnly(task.startDate);
+    return taskStart.getTime() < earliest.getTime() ? taskStart : earliest;
+  }, parseDateOnly(leafTasks[0]?.startDate ?? /* @__PURE__ */ new Date()));
+  const offsetFromProjectStart = (date) => {
+    const targetDate = parseDateOnly(date);
+    if (businessDays && weekendPredicate) {
+      return getBusinessDayOffset(projectStartDate, targetDate, weekendPredicate);
+    }
+    return Math.round((targetDate.getTime() - projectStartDate.getTime()) / DAY_MS);
+  };
+  const scheduledStart = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) {
+    scheduledStart.set(leaf.id, offsetFromProjectStart(leaf.startDate));
+  }
+  const succByPred = /* @__PURE__ */ new Map();
+  const predBySucc = /* @__PURE__ */ new Map();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const addEdge = (predecessorId, succId, lag, type) => {
+    const edgeKey = `${predecessorId}|${succId}|${type}`;
+    if (seenEdges.has(edgeKey)) return;
+    seenEdges.add(edgeKey);
+    const outEdges = succByPred.get(predecessorId) ?? [];
+    outEdges.push({ succId, lag, type });
+    succByPred.set(predecessorId, outEdges);
+    const inEdges = predBySucc.get(succId) ?? [];
+    inEdges.push({ predId: predecessorId, lag, type });
+    predBySucc.set(succId, inEdges);
+  };
+  for (const succ of leafTasks) {
+    for (const dep of succ.dependencies ?? []) {
+      const lag = getDependencyLag(dep);
+      if (leafIds.has(dep.taskId)) {
+        addEdge(dep.taskId, succ.id, lag, dep.type);
+        continue;
+      }
+      const descendants = leafIdsByAncestor.get(dep.taskId);
+      if (!descendants || descendants.size === 0) continue;
+      for (const leafId of descendants) {
+        if (leafId === succ.id) continue;
+        addEdge(leafId, succ.id, lag, dep.type);
       }
-      visited.add(task.id);
-      updatedDates.set(task.id, { start: newSuccStart, end: newSuccEnd });
-      result.push(normalizeTaskDependencyLags({
-        ...task,
-        startDate: newSuccStart.toISOString().split("T")[0],
-        endDate: newSuccEnd.toISOString().split("T")[0]
-      }));
-      queue.push(task.id);
     }
   }
-  return result;
-}
-function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes) {
-  const { childrenByParentId, dependentsByPredecessorId } = createCascadeContext(allTasks);
-  const directChildren = childrenByParentId.get(changedTaskId) ?? [];
-  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];
+  const indegree = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) indegree.set(leaf.id, 0);
+  for (const edges of succByPred.values()) {
+    for (const { succId } of edges) {
+      indegree.set(succId, (indegree.get(succId) ?? 0) + 1);
+    }
+  }
+  const order = [];
+  const enqueued = /* @__PURE__ */ new Set();
+  const queue = leafTasks.filter((leaf) => (indegree.get(leaf.id) ?? 0) === 0).map((leaf) => leaf.id);
+  for (const id of queue) enqueued.add(id);
   while (queue.length > 0) {
     const current = queue.shift();
-    const children = childrenByParentId.get(current.id) ?? [];
-    for (const child of children) {
-      if (!visited.has(child.id)) {
-        visited.add(child.id);
-        chain.push(child);
-        queue.push(child);
+    order.push(current);
+    for (const { succId } of succByPred.get(current) ?? []) {
+      const next = (indegree.get(succId) ?? 0) - 1;
+      indegree.set(succId, next);
+      if (next === 0 && !enqueued.has(succId)) {
+        enqueued.add(succId);
+        queue.push(succId);
       }
     }
-    const successors = dependentsByPredecessorId.get(current.id) ?? [];
-    for (const { task: successor } of successors) {
-      if (!visited.has(successor.id)) {
-        visited.add(successor.id);
-        chain.push(successor);
-        queue.push(successor);
-      }
+  }
+  const projectFinish = Math.max(
+    0,
+    ...leafTasks.map((leaf) => (scheduledStart.get(leaf.id) ?? 0) + durationOf(leaf))
+  );
+  const LF = /* @__PURE__ */ new Map();
+  const LS = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) LF.set(leaf.id, projectFinish);
+  for (let i = order.length - 1; i >= 0; i--) {
+    const id = order[i];
+    const task = taskById.get(id);
+    const durPred = durationOf(task);
+    const outEdges = succByPred.get(id) ?? [];
+    let lf = projectFinish;
+    if (outEdges.length > 0) {
+      const candidates = outEdges.map(({ succId, lag, type }) => {
+        const succLs = LS.get(succId) ?? projectFinish;
+        const durSucc = durationOf(taskById.get(succId));
+        switch (type) {
+          case "FS":
+            return succLs - lag;
+          case "SS":
+            return succLs - lag + durPred;
+          case "FF":
+            return succLs + durSucc - lag;
+          case "SF":
+            return succLs + durSucc - lag + durPred;
+          default:
+            return projectFinish;
+        }
+      });
+      lf = Math.min(projectFinish, ...candidates);
     }
+    LF.set(id, lf);
+    LS.set(id, lf - durPred);
   }
-  return chain;
+  const critical = /* @__PURE__ */ new Set();
+  const ordered = new Set(order);
+  for (const leaf of leafTasks) {
+    if (!ordered.has(leaf.id)) continue;
+    const hasGraphEdge = (succByPred.get(leaf.id)?.length ?? 0) > 0 || (predBySucc.get(leaf.id)?.length ?? 0) > 0;
+    if (!hasGraphEdge && (leaf.dependencies?.length ?? 0) > 0) continue;
+    const es = scheduledStart.get(leaf.id) ?? 0;
+    const ls = LS.get(leaf.id) ?? 0;
+    if (ls - es <= 0) critical.add(leaf.id);
+  }
+  return critical;
 }
-function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays = false, weekendPredicate, context = createCascadeContext(allTasks)) {
-  const { childrenByParentId, dependentsByPredecessorId, taskById } = context;
-  const normalizedMovedTask = normalizeTaskDependencyLags({
-    ...movedTask,
-    startDate: newStart.toISOString().split("T")[0],
-    endDate: newEnd.toISOString().split("T")[0]
-  });
-  if (!movedTask.parentId && !childrenByParentId.has(movedTask.id) && !dependentsByPredecessorId.has(movedTask.id)) {
-    return [normalizedMovedTask];
+function extendCriticalIdsToParents(criticalLeafIds, tasks) {
+  const result = new Set(criticalLeafIds);
+  const parentByChild = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.parentId) parentByChild.set(task.id, task.parentId);
   }
-  const updatedDates = /* @__PURE__ */ new Map();
-  updatedDates.set(movedTask.id, { start: newStart, end: newEnd });
-  const resultMap = /* @__PURE__ */ new Map();
-  resultMap.set(movedTask.id, normalizedMovedTask);
-  const queue = [[movedTask.id, "direct"]];
-  const childShifted = /* @__PURE__ */ new Set();
-  let iterations = 0;
-  const MAX_ITERATIONS = allTasks.length * 3;
-  while (queue.length > 0 && iterations < MAX_ITERATIONS) {
-    iterations++;
-    const [currentId, arrivalMode] = queue.shift();
-    const { start: currStart, end: currEnd } = updatedDates.get(currentId);
-    const currentOriginal = taskById.get(currentId);
-    if (arrivalMode !== "parent-recalc") {
-      const children = childrenByParentId.get(currentId) ?? [];
-      for (const child of children) {
-        if (childShifted.has(child.id) || child.locked) continue;
-        const parentOrigStart = new Date(currentOriginal.startDate);
-        const parentOrigEnd = new Date(currentOriginal.endDate);
-        const childOrigStart = new Date(child.startDate);
-        const childOrigEnd = new Date(child.endDate);
-        const startDeltaMs = currStart.getTime() - parentOrigStart.getTime();
-        const endDeltaMs = currEnd.getTime() - parentOrigEnd.getTime();
-        let childNewStart;
-        let childNewEnd;
-        if (businessDays && weekendPredicate) {
-          const proposedStart = new Date(childOrigStart.getTime() + startDeltaMs);
-          const snapDirection = currStart.getTime() >= parentOrigStart.getTime() ? 1 : -1;
-          const movedRange = moveTaskRange(
-            child.startDate,
-            child.endDate,
-            proposedStart,
-            true,
-            weekendPredicate,
-            snapDirection
-          );
-          childNewStart = movedRange.start;
-          childNewEnd = movedRange.end;
-        } else {
-          childNewStart = new Date(childOrigStart.getTime() + startDeltaMs);
-          childNewEnd = new Date(childOrigEnd.getTime() + endDeltaMs);
-        }
-        const prev = updatedDates.get(child.id);
-        if (prev && prev.start.getTime() === childNewStart.getTime() && prev.end.getTime() === childNewEnd.getTime()) {
-          continue;
-        }
-        updatedDates.set(child.id, { start: childNewStart, end: childNewEnd });
-        childShifted.add(child.id);
-        queue.push([child.id, "child-delta"]);
-        resultMap.set(child.id, normalizeTaskDependencyLags({
-          ...child,
-          startDate: childNewStart.toISOString().split("T")[0],
-          endDate: childNewEnd.toISOString().split("T")[0]
-        }));
-      }
-    }
-    const parentId = currentOriginal.parentId;
-    if (parentId && parentId !== movedTask.id) {
-      const parent = taskById.get(parentId);
-      if (parent && !parent.locked) {
-        const siblings = childrenByParentId.get(parentId) ?? [];
-        const siblingPositions = siblings.map((sib) => {
-          if (updatedDates.has(sib.id)) return updatedDates.get(sib.id);
-          return { start: new Date(sib.startDate), end: new Date(sib.endDate) };
-        });
-        const minStart = new Date(Math.min(...siblingPositions.map((p) => p.start.getTime())));
-        const maxEnd = new Date(Math.max(...siblingPositions.map((p) => p.end.getTime())));
-        const prev = updatedDates.get(parentId);
-        if (!prev || prev.start.getTime() !== minStart.getTime() || prev.end.getTime() !== maxEnd.getTime()) {
-          updatedDates.set(parentId, { start: minStart, end: maxEnd });
-          queue.push([parentId, "parent-recalc"]);
-          resultMap.set(parentId, normalizeTaskDependencyLags({
-            ...parent,
-            startDate: minStart.toISOString().split("T")[0],
-            endDate: maxEnd.toISOString().split("T")[0]
-          }));
-        }
-      }
-    }
-    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
-    for (const { task, dependencyIndex } of dependents) {
-      if (task.locked || !task.dependencies) continue;
-      if (childShifted.has(task.id)) continue;
-      const dep = task.dependencies[dependencyIndex];
-      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(
-        normalizedPredStart,
-        normalizedPredEnd,
-        dep.type,
-        getDependencyLag(dep),
-        businessDays,
-        weekendPredicate,
-        task.type
-      );
-      let succNewStart;
-      let succNewEnd;
-      const duration = getTaskDuration(origStart, origEnd, businessDays, weekendPredicate);
-      if (dep.type === "FS" || dep.type === "SS") {
-        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromStart(
-          constraintDate,
-          duration,
-          businessDays,
-          weekendPredicate
-        ));
-      } else {
-        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromEnd(
-          constraintDate,
-          duration,
-          businessDays,
-          weekendPredicate
-        ));
-      }
-      const prev = updatedDates.get(task.id);
-      if (prev && prev.start.getTime() === succNewStart.getTime() && prev.end.getTime() === succNewEnd.getTime()) {
-        continue;
-      }
-      updatedDates.set(task.id, { start: succNewStart, end: succNewEnd });
-      queue.push([task.id, "dependency"]);
-      resultMap.set(task.id, normalizeTaskDependencyLags({
-        ...task,
-        startDate: succNewStart.toISOString().split("T")[0],
-        endDate: succNewEnd.toISOString().split("T")[0]
-      }));
+  const stack = Array.from(criticalLeafIds);
+  while (stack.length > 0) {
+    const id = stack.pop();
+    const parentId = parentByChild.get(id);
+    if (parentId && !result.has(parentId)) {
+      result.add(parentId);
+      stack.push(parentId);
     }
   }
-  return Array.from(resultMap.values());
+  return result;
 }
 
-// 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);
+// src/core/scheduling/commands.ts
+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_MS7 = 24 * 60 * 60 * 1e3;
+  return {
+    start: normalizedStart,
+    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS7)
+  };
 }
-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 };
+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 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()));
+  const DAY_MS7 = 24 * 60 * 60 * 1e3;
   return {
-    startDate: new Date(minTime),
-    endDate: new Date(maxTime)
+    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS7),
+    end: normalizedEnd
   };
 }
-function computeParentProgress(parentId, tasks) {
-  const children = getChildren(parentId, tasks);
-  if (children.length === 0) {
-    return 0;
+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, taskById) {
+  if (!task.dependencies?.length) {
+    return { start: proposedStart, end: proposedEnd };
   }
-  const DAY_MS6 = 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_MS6) / DAY_MS6;
-    const progress = child.progress ?? 0;
-    totalWeight += duration;
-    weightedSum += duration * progress;
+  let minAllowedStart = null;
+  for (const dep of task.dependencies) {
+    if (dep.type !== "FS") {
+      continue;
+    }
+    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      continue;
+    }
+    const { predStart: predecessorStart, predEnd: predecessorEnd } = normalizePredecessorDates(predecessor, parseDateOnly);
+    const predecessorDuration = getTaskDuration(
+      predecessorStart,
+      predecessorEnd,
+      businessDays,
+      weekendPredicate
+    );
+    const candidateMinStart = calculateSuccessorDate(
+      predecessorStart,
+      predecessorEnd,
+      "FS",
+      -predecessorDuration,
+      businessDays,
+      weekendPredicate,
+      task.type
+    );
+    if (!minAllowedStart || candidateMinStart.getTime() > minAllowedStart.getTime()) {
+      minAllowedStart = candidateMinStart;
+    }
   }
-  if (totalWeight === 0) {
-    return 0;
+  if (!minAllowedStart || proposedStart.getTime() >= minAllowedStart.getTime()) {
+    return { start: proposedStart, end: proposedEnd };
   }
-  return Math.round(weightedSum / totalWeight * 10) / 10;
+  return buildTaskRangeFromStart(
+    minAllowedStart,
+    getTaskDuration(proposedStart, proposedEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate
+  );
 }
-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);
+function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate, taskById) {
+  if (!task.dependencies) return [];
+  return task.dependencies.map((dep) => {
+    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      return { ...dep, lag: getDependencyLag(dep) };
     }
+    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,
+      predecessorEnd,
+      newStartDate,
+      newEndDate,
+      businessDays,
+      weekendPredicate,
+      task.type
+    );
+    return { ...dep, lag: nextLag };
+  });
+}
+
+// src/core/scheduling/cascade.ts
+function parseCascadeDateInput(date) {
+  if (date instanceof Date) {
+    return normalizeUTCDate(date);
   }
-  collectChildren(parentId);
-  return descendants;
+  return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
 }
-function cascadeTaskProgress(task, tasks) {
-  const progress = task.progress;
-  if (progress !== 0 && progress !== 100) {
-    return [task];
+function projectDayDelta(from, to, businessDays, weekendPredicate) {
+  if (businessDays && weekendPredicate) {
+    return getBusinessDayOffset(from, to, weekendPredicate);
   }
-  const descendants = getAllDescendants(task.id, tasks);
-  if (descendants.length === 0) {
-    return [task];
+  return Math.round((to.getTime() - from.getTime()) / DAY_MS);
+}
+function shiftTaskActivities(activities, dayDelta, businessDays, weekendPredicate) {
+  if (!activities || activities.length === 0 || dayDelta === 0) return void 0;
+  const shiftDate = (value) => {
+    const base = parseDateOnly(value);
+    const shifted = businessDays && weekendPredicate ? shiftBusinessDayOffset(base, dayDelta, weekendPredicate) : new Date(base.getTime() + dayDelta * DAY_MS);
+    return typeof value === "string" ? shifted.toISOString().slice(0, 10) : shifted;
+  };
+  return activities.map((activity) => ({
+    ...activity,
+    startDate: shiftDate(activity.startDate),
+    endDate: shiftDate(activity.endDate)
+  }));
+}
+function shiftedActivitiesPatch(activities, dayDelta, businessDays, weekendPredicate) {
+  const shifted = shiftTaskActivities(activities, dayDelta, businessDays, weekendPredicate);
+  return shifted ? { activities: shifted } : {};
+}
+function createCascadeContext(allTasks) {
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const dependentsByPredecessorId = /* @__PURE__ */ new Map();
+  const taskById = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    taskById.set(task.id, task);
+    if (task.parentId) {
+      const children = childrenByParentId.get(task.parentId) ?? [];
+      children.push(task);
+      childrenByParentId.set(task.parentId, children);
+    }
+    if (!task.dependencies) continue;
+    task.dependencies.forEach((dependency, dependencyIndex) => {
+      const dependents = dependentsByPredecessorId.get(dependency.taskId) ?? [];
+      dependents.push({ task, dependencyIndex });
+      dependentsByPredecessorId.set(dependency.taskId, dependents);
+    });
   }
-  return [
-    { ...task, progress },
-    ...descendants.map((descendant) => ({ ...descendant, progress }))
-  ];
+  return { childrenByParentId, dependentsByPredecessorId, taskById };
 }
-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
-        });
+function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
+  const { dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [draggedTaskId];
+  const chain = [];
+  visited.add(draggedTaskId);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const successors = dependentsByPredecessorId.get(current) ?? [];
+    for (const { task } of successors) {
+      if (!linkTypes.includes(task.dependencies?.find((dependency) => dependency.taskId === current)?.type ?? "FS")) {
+        continue;
+      }
+      const sid = task.id;
+      if (!visited.has(sid)) {
+        visited.add(sid);
+        const successorTask = taskById.get(sid);
+        if (successorTask) {
+          chain.push(successorTask);
+          queue.push(sid);
+        }
       }
     }
   }
-  return edges;
+  return chain;
 }
-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;
+function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascade = false) {
+  const { childrenByParentId, dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
+  const updatedDates = /* @__PURE__ */ new Map();
+  updatedDates.set(movedTaskId, { start: newStart, end: newEnd });
+  const result = [];
+  const queue = [movedTaskId];
+  const visited = /* @__PURE__ */ new Set([movedTaskId]);
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    const { start: predStart, end: predEnd } = updatedDates.get(currentId);
+    if (!skipChildCascade) {
+      const children = childrenByParentId.get(currentId) ?? [];
+      for (const child of children) {
+        if (visited.has(child.id) || child.locked) continue;
+        const origStart = new Date(child.startDate);
+        const origEnd = new Date(child.endDate);
+        const durationMs = origEnd.getTime() - origStart.getTime();
+        const parentOrig = taskById.get(currentId);
+        const parentOrigStart = new Date(parentOrig.startDate);
+        const parentOrigEnd = new Date(parentOrig.endDate);
+        const parentStartDelta = predStart.getTime() - parentOrigStart.getTime();
+        const parentEndDelta = predEnd.getTime() - parentOrigEnd.getTime();
+        const newChildStart = new Date(origStart.getTime() + parentStartDelta);
+        const newChildEnd = new Date(origEnd.getTime() + parentEndDelta);
+        visited.add(child.id);
+        updatedDates.set(child.id, { start: newChildStart, end: newChildEnd });
+        result.push(normalizeTaskDependencyLags({
+          ...child,
+          startDate: newChildStart.toISOString().split("T")[0],
+          endDate: newChildEnd.toISOString().split("T")[0],
+          ...shiftedActivitiesPatch(child.activities, Math.round(parentStartDelta / DAY_MS), false)
+        }));
+        queue.push(child.id);
       }
-      return {
+    }
+    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
+    for (const { task, dependencyIndex } of dependents) {
+      if (visited.has(task.id) || !task.dependencies || task.locked) continue;
+      const dep = task.dependencies[dependencyIndex];
+      if (!dep) 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 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),
+        false,
+        void 0,
+        task.type
+      );
+      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(normalizeTaskDependencyLags({
         ...task,
-        dependencies: filteredDependencies.length > 0 ? filteredDependencies : void 0
-      };
+        startDate: newSuccStart.toISOString().split("T")[0],
+        endDate: newSuccEnd.toISOString().split("T")[0]
+      }));
+      queue.push(task.id);
     }
-    return task;
-  });
-}
-function findParentId(taskId, tasks) {
-  const task = tasks.find((t) => t.id === taskId);
-  return task?.parentId;
+  }
+  return result;
 }
-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;
+function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes) {
+  const { childrenByParentId, dependentsByPredecessorId } = createCascadeContext(allTasks);
+  const directChildren = childrenByParentId.get(changedTaskId) ?? [];
+  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 = childrenByParentId.get(current.id) ?? [];
+    for (const child of children) {
+      if (!visited.has(child.id)) {
+        visited.add(child.id);
+        chain.push(child);
+        queue.push(child);
+      }
     }
-    if (visited.has(current.parentId)) {
-      return false;
+    const successors = dependentsByPredecessorId.get(current.id) ?? [];
+    for (const { task: successor } of successors) {
+      if (!visited.has(successor.id)) {
+        visited.add(successor.id);
+        chain.push(successor);
+        queue.push(successor);
+      }
     }
-    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/execute.ts
-function toIsoDate(date) {
-  return date.toISOString().split("T")[0];
-}
-function createChangedResult(snapshot, nextTasks) {
-  const originalById = new Map(snapshot.map((task) => [task.id, task]));
-  const changedTasks = nextTasks.filter((task) => JSON.stringify(originalById.get(task.id)) !== JSON.stringify(task));
-  return {
-    changedTasks,
-    changedIds: changedTasks.map((task) => task.id)
-  };
+  return chain;
 }
-function moveTaskWithCascade(taskId, newStart, snapshot, options) {
-  const task = snapshot.find((t) => t.id === taskId);
-  if (!task) {
-    return { changedTasks: [], changedIds: [] };
-  }
-  const businessDays = options?.businessDays ?? false;
-  const weekendPredicate = options?.weekendPredicate;
-  const newRange = moveTaskRange(
-    task.startDate,
-    task.endDate,
-    newStart,
-    businessDays,
-    weekendPredicate
-  );
-  const updatedDependencies = recalculateIncomingLags(
-    task,
-    newRange.start,
-    newRange.end,
-    snapshot,
-    businessDays,
-    weekendPredicate
-  );
-  const movedTask = {
-    ...task,
-    startDate: newRange.start.toISOString().split("T")[0],
-    endDate: newRange.end.toISOString().split("T")[0],
-    dependencies: updatedDependencies
-  };
-  if (options?.skipCascade) {
-    return {
-      changedTasks: [movedTask],
-      changedIds: [movedTask.id]
-    };
+function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays = false, weekendPredicate, context = createCascadeContext(allTasks)) {
+  const { childrenByParentId, dependentsByPredecessorId, taskById } = context;
+  const normalizedMovedTask = normalizeTaskDependencyLags({
+    ...movedTask,
+    startDate: newStart.toISOString().split("T")[0],
+    endDate: newEnd.toISOString().split("T")[0]
+  });
+  if (!movedTask.parentId && !childrenByParentId.has(movedTask.id) && !dependentsByPredecessorId.has(movedTask.id)) {
+    return [normalizedMovedTask];
   }
-  const cascadeResult = universalCascade(
-    movedTask,
-    newRange.start,
-    newRange.end,
-    snapshot,
-    businessDays,
-    weekendPredicate
-  );
+  const updatedDates = /* @__PURE__ */ new Map();
+  updatedDates.set(movedTask.id, { start: newStart, end: newEnd });
   const resultMap = /* @__PURE__ */ new Map();
-  resultMap.set(movedTask.id, movedTask);
-  for (const t of cascadeResult) {
-    resultMap.set(t.id, t);
+  resultMap.set(movedTask.id, normalizedMovedTask);
+  const queue = [[movedTask.id, "direct"]];
+  const childShifted = /* @__PURE__ */ new Set();
+  let iterations = 0;
+  const MAX_ITERATIONS = allTasks.length * 3;
+  while (queue.length > 0 && iterations < MAX_ITERATIONS) {
+    iterations++;
+    const [currentId, arrivalMode] = queue.shift();
+    const { start: currStart, end: currEnd } = updatedDates.get(currentId);
+    const currentOriginal = taskById.get(currentId);
+    if (arrivalMode !== "parent-recalc") {
+      const children = childrenByParentId.get(currentId) ?? [];
+      for (const child of children) {
+        if (childShifted.has(child.id) || child.locked) continue;
+        const parentOrigStart = new Date(currentOriginal.startDate);
+        const parentOrigEnd = new Date(currentOriginal.endDate);
+        const childOrigStart = new Date(child.startDate);
+        const childOrigEnd = new Date(child.endDate);
+        const startDeltaMs = currStart.getTime() - parentOrigStart.getTime();
+        const endDeltaMs = currEnd.getTime() - parentOrigEnd.getTime();
+        let childNewStart;
+        let childNewEnd;
+        if (businessDays && weekendPredicate) {
+          const proposedStart = new Date(childOrigStart.getTime() + startDeltaMs);
+          const snapDirection = currStart.getTime() >= parentOrigStart.getTime() ? 1 : -1;
+          const movedRange = moveTaskRange(
+            child.startDate,
+            child.endDate,
+            proposedStart,
+            true,
+            weekendPredicate,
+            snapDirection
+          );
+          childNewStart = movedRange.start;
+          childNewEnd = movedRange.end;
+        } else {
+          childNewStart = new Date(childOrigStart.getTime() + startDeltaMs);
+          childNewEnd = new Date(childOrigEnd.getTime() + endDeltaMs);
+        }
+        const prev = updatedDates.get(child.id);
+        if (prev && prev.start.getTime() === childNewStart.getTime() && prev.end.getTime() === childNewEnd.getTime()) {
+          continue;
+        }
+        updatedDates.set(child.id, { start: childNewStart, end: childNewEnd });
+        childShifted.add(child.id);
+        queue.push([child.id, "child-delta"]);
+        resultMap.set(child.id, normalizeTaskDependencyLags({
+          ...child,
+          startDate: childNewStart.toISOString().split("T")[0],
+          endDate: childNewEnd.toISOString().split("T")[0],
+          // Дети едут параллельно: вместе с датами строки сдвигаются и её работы.
+          ...shiftedActivitiesPatch(
+            child.activities,
+            projectDayDelta(childOrigStart, childNewStart, businessDays, weekendPredicate),
+            businessDays,
+            weekendPredicate
+          )
+        }));
+      }
+    }
+    const parentId = currentOriginal.parentId;
+    if (parentId && parentId !== movedTask.id) {
+      const parent = taskById.get(parentId);
+      if (parent && !parent.locked) {
+        const siblings = childrenByParentId.get(parentId) ?? [];
+        const siblingPositions = siblings.map((sib) => {
+          if (updatedDates.has(sib.id)) return updatedDates.get(sib.id);
+          return { start: new Date(sib.startDate), end: new Date(sib.endDate) };
+        });
+        const minStart = new Date(Math.min(...siblingPositions.map((p) => p.start.getTime())));
+        const maxEnd = new Date(Math.max(...siblingPositions.map((p) => p.end.getTime())));
+        const prev = updatedDates.get(parentId);
+        if (!prev || prev.start.getTime() !== minStart.getTime() || prev.end.getTime() !== maxEnd.getTime()) {
+          updatedDates.set(parentId, { start: minStart, end: maxEnd });
+          queue.push([parentId, "parent-recalc"]);
+          resultMap.set(parentId, normalizeTaskDependencyLags({
+            ...parent,
+            startDate: minStart.toISOString().split("T")[0],
+            endDate: maxEnd.toISOString().split("T")[0]
+          }));
+        }
+      }
+    }
+    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
+    for (const { task, dependencyIndex } of dependents) {
+      if (task.locked || !task.dependencies) continue;
+      if (childShifted.has(task.id)) continue;
+      const dep = task.dependencies[dependencyIndex];
+      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(
+        normalizedPredStart,
+        normalizedPredEnd,
+        dep.type,
+        getDependencyLag(dep),
+        businessDays,
+        weekendPredicate,
+        task.type
+      );
+      let succNewStart;
+      let succNewEnd;
+      const duration = getTaskDuration(origStart, origEnd, businessDays, weekendPredicate);
+      if (dep.type === "FS" || dep.type === "SS") {
+        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromStart(
+          constraintDate,
+          duration,
+          businessDays,
+          weekendPredicate
+        ));
+      } else {
+        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromEnd(
+          constraintDate,
+          duration,
+          businessDays,
+          weekendPredicate
+        ));
+      }
+      const prev = updatedDates.get(task.id);
+      if (prev && prev.start.getTime() === succNewStart.getTime() && prev.end.getTime() === succNewEnd.getTime()) {
+        continue;
+      }
+      updatedDates.set(task.id, { start: succNewStart, end: succNewEnd });
+      queue.push([task.id, "dependency"]);
+      resultMap.set(task.id, normalizeTaskDependencyLags({
+        ...task,
+        startDate: succNewStart.toISOString().split("T")[0],
+        endDate: succNewEnd.toISOString().split("T")[0],
+        ...shiftedActivitiesPatch(
+          task.activities,
+          projectDayDelta(origStart, succNewStart, businessDays, weekendPredicate),
+          businessDays,
+          weekendPredicate
+        )
+      }));
+    }
   }
-  const changedTasks = Array.from(resultMap.values());
+  return Array.from(resultMap.values());
+}
+
+// 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 {
-    changedTasks,
-    changedIds: changedTasks.map((t) => t.id)
+    startDate: new Date(minTime),
+    endDate: new Date(maxTime)
   };
 }
-function resizeTaskWithCascade(taskId, anchor, newDate, snapshot, options) {
-  const task = snapshot.find((t) => t.id === taskId);
-  if (!task) {
-    return { changedTasks: [], changedIds: [] };
-  }
-  const businessDays = options?.businessDays ?? false;
-  const weekendPredicate = options?.weekendPredicate;
-  const originalStart = parseDateOnly(task.startDate);
-  const originalEnd = parseDateOnly(task.endDate);
-  let newRange;
-  if (anchor === "start") {
-    newRange = { start: originalStart, end: newDate };
-  } else {
-    newRange = { start: newDate, end: originalEnd };
+function computeParentProgress(parentId, tasks) {
+  const children = getChildren(parentId, tasks);
+  if (children.length === 0) {
+    return 0;
   }
-  const updatedDependencies = recalculateIncomingLags(
-    task,
-    newRange.start,
-    newRange.end,
-    snapshot,
-    businessDays,
-    weekendPredicate
-  );
-  const resizedTask = {
-    ...task,
-    startDate: newRange.start.toISOString().split("T")[0],
-    endDate: newRange.end.toISOString().split("T")[0],
-    dependencies: updatedDependencies
-  };
-  if (options?.skipCascade) {
-    return {
-      changedTasks: [resizedTask],
-      changedIds: [resizedTask.id]
-    };
+  const DAY_MS7 = 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_MS7) / DAY_MS7;
+    const progress = child.progress ?? 0;
+    totalWeight += duration;
+    weightedSum += duration * progress;
   }
-  const cascadeResult = universalCascade(
-    resizedTask,
-    newRange.start,
-    newRange.end,
-    snapshot,
-    businessDays,
-    weekendPredicate
-  );
-  const resultMap = /* @__PURE__ */ new Map();
-  resultMap.set(resizedTask.id, resizedTask);
-  for (const t of cascadeResult) {
-    resultMap.set(t.id, t);
+  if (totalWeight === 0) {
+    return 0;
   }
-  const changedTasks = Array.from(resultMap.values());
-  return {
-    changedTasks,
-    changedIds: changedTasks.map((t) => t.id)
-  };
+  return Math.round(weightedSum / totalWeight * 10) / 10;
 }
-function recalculateTaskFromDependencies(taskId, snapshot, options) {
-  const task = snapshot.find((t) => t.id === taskId);
-  if (!task) {
-    return { changedTasks: [], changedIds: [] };
+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);
+    }
   }
-  const businessDays = options?.businessDays ?? false;
+  collectChildren(parentId);
+  return descendants;
+}
+function cascadeTaskProgress(task, tasks) {
+  const progress = task.progress;
+  if (progress !== 0 && progress !== 100) {
+    return [task];
+  }
+  const descendants = getAllDescendants(task.id, tasks);
+  if (descendants.length === 0) {
+    return [task];
+  }
+  return [
+    { ...task, progress },
+    ...descendants.map((descendant) => ({ ...descendant, progress }))
+  ];
+}
+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/execute.ts
+function toIsoDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function createChangedResult(snapshot, nextTasks) {
+  const originalById = new Map(snapshot.map((task) => [task.id, task]));
+  const changedTasks = nextTasks.filter((task) => JSON.stringify(originalById.get(task.id)) !== JSON.stringify(task));
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((task) => task.id)
+  };
+}
+function moveTaskWithCascade(taskId, newStart, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  const newRange = moveTaskRange(
+    task.startDate,
+    task.endDate,
+    newStart,
+    businessDays,
+    weekendPredicate
+  );
+  const updatedDependencies = recalculateIncomingLags(
+    task,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const movedTask = {
+    ...task,
+    startDate: newRange.start.toISOString().split("T")[0],
+    endDate: newRange.end.toISOString().split("T")[0],
+    dependencies: updatedDependencies
+  };
+  if (options?.skipCascade) {
+    return {
+      changedTasks: [movedTask],
+      changedIds: [movedTask.id]
+    };
+  }
+  const cascadeResult = universalCascade(
+    movedTask,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(movedTask.id, movedTask);
+  for (const t of cascadeResult) {
+    resultMap.set(t.id, t);
+  }
+  const changedTasks = Array.from(resultMap.values());
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((t) => t.id)
+  };
+}
+function resizeTaskWithCascade(taskId, anchor, newDate, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  const originalStart = parseDateOnly(task.startDate);
+  const originalEnd = parseDateOnly(task.endDate);
+  let newRange;
+  if (anchor === "start") {
+    newRange = { start: originalStart, end: newDate };
+  } else {
+    newRange = { start: newDate, end: originalEnd };
+  }
+  const updatedDependencies = recalculateIncomingLags(
+    task,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resizedTask = {
+    ...task,
+    startDate: newRange.start.toISOString().split("T")[0],
+    endDate: newRange.end.toISOString().split("T")[0],
+    dependencies: updatedDependencies
+  };
+  if (options?.skipCascade) {
+    return {
+      changedTasks: [resizedTask],
+      changedIds: [resizedTask.id]
+    };
+  }
+  const cascadeResult = universalCascade(
+    resizedTask,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(resizedTask.id, resizedTask);
+  for (const t of cascadeResult) {
+    resultMap.set(t.id, t);
+  }
+  const changedTasks = Array.from(resultMap.values());
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((t) => t.id)
+  };
+}
+function recalculateTaskFromDependencies(taskId, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
   const weekendPredicate = options?.weekendPredicate;
   if (!task.dependencies || task.dependencies.length === 0) {
     return {
@@ -2886,7 +3424,11 @@ function flattenHierarchy(tasks) {
 }
 function normalizeHierarchyTasks(tasks) {
   const orderedTasks = flattenHierarchy(tasks).map((task) => {
-    const { startDate, endDate } = normalizeTaskDates(task.startDate, task.endDate);
+    const bounds = activityBounds(task.activities);
+    const { startDate, endDate } = normalizeTaskDates(
+      bounds?.startDate ?? task.startDate,
+      bounds?.endDate ?? task.endDate
+    );
     return { ...task, startDate, endDate };
   });
   const childrenByParent = /* @__PURE__ */ new Map();
@@ -2897,7 +3439,7 @@ function normalizeHierarchyTasks(tasks) {
     children.push(index);
     childrenByParent.set(parentId, children);
   }
-  const DAY_MS6 = 24 * 60 * 60 * 1e3;
+  const DAY_MS7 = 24 * 60 * 60 * 1e3;
   for (let index = orderedTasks.length - 1; index >= 0; index--) {
     const children = childrenByParent.get(orderedTasks[index].id);
     if (!children?.length) continue;
@@ -2911,7 +3453,7 @@ function normalizeHierarchyTasks(tasks) {
       const end = new Date(child.endDate).getTime();
       minStart = Math.min(minStart, start);
       maxEnd = Math.max(maxEnd, end);
-      const duration = (end - start + DAY_MS6) / DAY_MS6;
+      const duration = (end - start + DAY_MS7) / DAY_MS7;
       totalWeight += duration;
       weightedProgress += duration * (child.progress ?? 0);
     }
@@ -3067,361 +3609,96 @@ var TimeScaleHeader = ({
                 },
                 `month-${index}`
               ))
-            )
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          "div",
-          {
-            className: "gantt-tsh-dayRow",
-            style: {
-              height: `${rowHeight}px`,
-              gridTemplateColumns: viewMode === "week" ? weekGridTemplate : viewMode === "month" ? monthGridTemplate : dayGridTemplate
-            },
-            children: viewMode === "week" ? (
-              // Week-view row 2: week block start day numbers (variable width)
-              weekBlocks.map((block, index) => {
-                const prevBlock = weekBlocks[index - 1];
-                const isMonthBoundary = index > 0 && prevBlock && prevBlock.startDate.getUTCMonth() !== block.startDate.getUTCMonth();
-                const showDate = block.days === 7;
-                return /* @__PURE__ */ jsx(
-                  "div",
-                  {
-                    className: "gantt-tsh-dayCell gantt-tsh-weekCell",
-                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: showDate ? String(block.startDate.getUTCDate()).padStart(2, "0") : "" })
-                  },
-                  `week-${index}`
-                );
-              })
-            ) : viewMode === "month" ? (
-              // Month-view row 2: one column per month, shows abbreviated month name
-              monthBlocks.map((block, index) => {
-                const MIN_DAYS_TO_SHOW_LABEL = 15;
-                const showLabel = block.days >= MIN_DAYS_TO_SHOW_LABEL;
-                const isYearBoundary = index > 0 && block.startDate.getUTCMonth() === 0;
-                return /* @__PURE__ */ jsx(
-                  "div",
-                  {
-                    className: "gantt-tsh-dayCell gantt-tsh-weekCell",
-                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: showLabel ? (() => {
-                      const s = block.startDate.toLocaleString("ru-RU", { month: "long", timeZone: "UTC" });
-                      return s.charAt(0).toUpperCase() + s.slice(1);
-                    })() : "" })
-                  },
-                  `mblock-${index}`
-                );
-              })
-            ) : (
-              // Day-view row 2: individual day numbers (existing code)
-              days.map((day, index) => {
-                const isWeekendDay = isCustomWeekend ? isCustomWeekend(day) : day.getUTCDay() === 0 || day.getUTCDay() === 6;
-                const prevDay = days[index - 1];
-                const isMonthBoundary = index > 0 && prevDay && prevDay.getUTCMonth() !== day.getUTCMonth();
-                const isTodayDate = day.getUTCFullYear() === today.getUTCFullYear() && day.getUTCMonth() === today.getUTCMonth() && day.getUTCDate() === today.getUTCDate();
-                const markerKey = `${day.getUTCFullYear()}-${day.getUTCMonth()}-${day.getUTCDate()}`;
-                const marker = markerByDayKey.get(markerKey);
-                const markerColor = marker?.color;
-                const formattedDate = `${String(day.getUTCDate()).padStart(2, "0")}.${String(day.getUTCMonth() + 1).padStart(2, "0")}.${String(day.getUTCFullYear()).slice(-2)}`;
-                const tooltipText = isTodayDate ? `${formattedDate} \u2014 \u0421\u0435\u0433\u043E\u0434\u043D\u044F` : marker?.name ? `${formattedDate} \u2014 ${marker.name}` : void 0;
-                return /* @__PURE__ */ jsx(
-                  "div",
-                  {
-                    className: `gantt-tsh-dayCell ${isWeekendDay ? "gantt-tsh-weekendDay" : ""} ${isTodayDate ? "gantt-tsh-today" : ""} ${marker && !isTodayDate ? "gantt-tsh-markerDay" : ""} ${tooltipText ? "gantt-tsh-dayCell-tooltipTrigger" : ""}`,
-                    style: markerColor && !isTodayDate ? {
-                      ["--gantt-marker-day-color"]: markerColor
-                    } : void 0,
-                    "aria-label": tooltipText,
-                    onMouseEnter: () => {
-                      if (!tooltipText) return;
-                      onTimelineHover?.({
-                        label: tooltipText,
-                        left: index * dayWidth,
-                        color: isTodayDate ? "#dc2626" : markerColor || "var(--gantt-timeline-marker-color, #dc2626)"
-                      });
-                    },
-                    onMouseLeave: onTimelineHoverEnd,
-                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: format(day, "d") })
-                  },
-                  `day-${index}`
-                );
-              })
-            )
-          }
-        )
-      ]
-    }
-  );
-};
-var TimeScaleHeader_default = TimeScaleHeader;
-
-// src/components/TaskRow/TaskRow.tsx
-import React2, { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
-import { createPortal } from "react-dom";
-
-// src/utils/geometry.ts
-var getUTCDayDifference = (date1, date2) => {
-  const ms1 = Date.UTC(
-    date1.getUTCFullYear(),
-    date1.getUTCMonth(),
-    date1.getUTCDate()
-  );
-  const ms2 = Date.UTC(
-    date2.getUTCFullYear(),
-    date2.getUTCMonth(),
-    date2.getUTCDate()
-  );
-  return Math.round((ms1 - ms2) / (1e3 * 60 * 60 * 24));
-};
-var calculateTaskBar = (taskStartDate, taskEndDate, monthStart, dayWidth) => {
-  const startOffset = getUTCDayDifference(taskStartDate, monthStart);
-  const duration = getUTCDayDifference(taskEndDate, taskStartDate);
-  const left = Math.round(startOffset * 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 centerX = Math.round(dayLeft + dayWidth / 2);
-  return {
-    left: centerX - halfDiagonal,
-    right: centerX + halfDiagonal
-  };
-};
-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) {
-      const bounds2 = calculateMilestoneConnectionBounds(override.left, dayWidth, size);
-      return {
-        ...bounds2,
-        centerX: Math.round(override.left + dayWidth / 2)
-      };
-    }
-    const bar2 = calculateTaskBar(startDate, startDate, monthStart, dayWidth);
-    const bounds = calculateMilestoneConnectionBounds(bar2.left, dayWidth, size);
-    return {
-      ...bounds,
-      centerX: Math.round(bar2.left + dayWidth / 2)
-    };
-  }
-  if (override) {
-    return {
-      left: override.left,
-      right: override.left + override.width,
-      centerX: Math.round(override.left + override.width / 2)
-    };
-  }
-  const bar = calculateTaskBar(startDate, endDate, monthStart, dayWidth);
-  return {
-    left: bar.left,
-    right: bar.left + bar.width,
-    centerX: Math.round(bar.left + bar.width / 2)
-  };
-};
-var pixelsToDate = (pixels, monthStart, dayWidth) => {
-  const days = Math.round(pixels / dayWidth);
-  return new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + days
-  ));
-};
-var calculateGridWidth = (daysInMonth, dayWidth) => {
-  return Math.round(daysInMonth * dayWidth);
-};
-var MIN_EDGE_ZONE_PX = 8;
-var MIN_MOVE_ZONE_PX = 16;
-var detectEdgeZone = (clientX, taskBarElement, edgeZoneWidth = 12) => {
-  const rect = taskBarElement.getBoundingClientRect();
-  const relativeX = Math.round(clientX - rect.left);
-  const width = Math.round(rect.width);
-  const effectiveZone = Math.max(
-    MIN_EDGE_ZONE_PX,
-    Math.min(edgeZoneWidth, (width - MIN_MOVE_ZONE_PX) / 2)
-  );
-  if (relativeX >= 0 && relativeX <= effectiveZone) {
-    return "left";
-  }
-  if (relativeX >= width - effectiveZone && relativeX <= width) {
-    return "right";
-  }
-  return "move";
-};
-var getCursorForPosition = (position) => {
-  switch (position) {
-    case "left":
-    case "right":
-      return "ew-resize";
-    case "move":
-      return "grab";
-    default:
-      return "default";
-  }
-};
-var calculateGridLines = (dateRange, dayWidth) => {
-  const lines = [];
-  for (let i = 0; i < dateRange.length; i++) {
-    const date = dateRange[i];
-    const x = Math.round(i * dayWidth);
-    const isMonthStart = i === 0 ? false : date.getUTCDate() === 1;
-    const isWeekStart = date.getUTCDay() === 1;
-    lines.push({ x, isMonthStart, isWeekStart });
-  }
-  if (dateRange.length > 0) {
-    lines.push({
-      x: Math.round(dateRange.length * dayWidth),
-      isMonthStart: false,
-      isWeekStart: false
-    });
-  }
-  return lines;
-};
-var calculateWeekendBlocks = (dateRange, dayWidth, isCustomWeekend) => {
-  const blocks = [];
-  let inWeekend = false;
-  let weekendStartIndex = -1;
-  for (let i = 0; i < dateRange.length; i++) {
-    const date = dateRange[i];
-    const isWeekend3 = isCustomWeekend ? isCustomWeekend(date) : date.getUTCDay() === 0 || date.getUTCDay() === 6;
-    if (isWeekend3 && !inWeekend) {
-      inWeekend = true;
-      weekendStartIndex = i;
-    } else if (!isWeekend3 && inWeekend) {
-      inWeekend = false;
-      const left = Math.round(weekendStartIndex * dayWidth);
-      const width = Math.round((i - weekendStartIndex) * dayWidth);
-      blocks.push({ left, width });
-    }
-  }
-  if (inWeekend && weekendStartIndex >= 0) {
-    const left = Math.round(weekendStartIndex * dayWidth);
-    const width = Math.round((dateRange.length - weekendStartIndex) * dayWidth);
-    blocks.push({ left, width });
-  }
-  return blocks;
-};
-var calculateBezierPath = (from, to) => {
-  const verticalDistance = Math.abs(to.y - from.y);
-  const cpOffset = Math.max(verticalDistance * 0.5, 20);
-  if (from.y === to.y) {
-    const arcHeight = 20;
-    const midX = (from.x + to.x) / 2;
-    return `M ${from.x} ${from.y} Q ${midX} ${from.y - arcHeight} ${to.x} ${to.y}`;
-  }
-  const cp1x = from.x;
-  const cp1y = from.y + (to.y > from.y ? cpOffset : -cpOffset);
-  const cp2x = to.x;
-  const cp2y = to.y - (to.y > from.y ? cpOffset : -cpOffset);
-  return `M ${Math.round(from.x)} ${Math.round(from.y)} C ${Math.round(cp1x)} ${Math.round(cp1y)}, ${Math.round(cp2x)} ${Math.round(cp2y)}, ${Math.round(to.x)} ${Math.round(to.y)}`;
-};
-var calculateDependencyPath = (from, to, arrivesFromRight) => {
-  const fx = Math.round(from.x);
-  const fy = Math.round(from.y);
-  const tx = Math.round(to.x);
-  const ty = Math.round(to.y);
-  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;
-  if (arrivesFromRight) {
-    const goingRight = tx >= fx;
-    const dirX = goingRight ? 1 : -1;
-    if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
-      return [
-        `M ${fx} ${fy}`,
-        `H ${tx - dirX * C}`,
-        `L ${tx} ${fy + dirY * C}`,
-        `V ${ty}`
-      ].join(" ");
-    }
-    return `M ${fx} ${fy} H ${tx} V ${ty}`;
-  } else {
-    const goingRight = tx >= fx;
-    const dirX = goingRight ? 1 : -1;
-    if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
-      return [
-        `M ${fx} ${fy}`,
-        `H ${tx - dirX * C}`,
-        `L ${tx} ${fy + dirY * C}`,
-        `V ${ty}`
-      ].join(" ");
-    }
-    return `M ${fx} ${fy} H ${tx} V ${ty}`;
-  }
-};
-var calculateWeekGridLines = (dateRange, dayWidth) => {
-  const blocks = getWeekBlocks(dateRange);
-  const lines = [];
-  let currentDayIndex = 0;
-  for (let i = 0; i < blocks.length; i++) {
-    const block = blocks[i];
-    currentDayIndex += block.days;
-    const blockEndMonth = dateRange[currentDayIndex - 1];
-    const nextBlockMonth = currentDayIndex < dateRange.length ? dateRange[currentDayIndex] : null;
-    const isMonthBoundary = nextBlockMonth && blockEndMonth.getUTCMonth() !== nextBlockMonth.getUTCMonth();
-    lines.push({
-      x: Math.round(currentDayIndex * dayWidth),
-      isMonthStart: isMonthBoundary || false
-    });
-  }
-  if (lines.length > 0 && lines[lines.length - 1].x === Math.round(dateRange.length * dayWidth)) {
-    lines.pop();
-  }
-  return lines;
-};
-var calculateMonthGridLines = (dateRange, dayWidth) => {
-  const lines = [];
-  for (let i = 1; i < dateRange.length; i++) {
-    const date = dateRange[i];
-    if (date.getUTCDate() === 1) {
-      const x = Math.round(i * dayWidth);
-      const isYearBoundary = date.getUTCMonth() === 0;
-      lines.push({ x, isMonthStart: isYearBoundary });
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "gantt-tsh-dayRow",
+            style: {
+              height: `${rowHeight}px`,
+              gridTemplateColumns: viewMode === "week" ? weekGridTemplate : viewMode === "month" ? monthGridTemplate : dayGridTemplate
+            },
+            children: viewMode === "week" ? (
+              // Week-view row 2: week block start day numbers (variable width)
+              weekBlocks.map((block, index) => {
+                const prevBlock = weekBlocks[index - 1];
+                const isMonthBoundary = index > 0 && prevBlock && prevBlock.startDate.getUTCMonth() !== block.startDate.getUTCMonth();
+                const showDate = block.days === 7;
+                return /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "gantt-tsh-dayCell gantt-tsh-weekCell",
+                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: showDate ? String(block.startDate.getUTCDate()).padStart(2, "0") : "" })
+                  },
+                  `week-${index}`
+                );
+              })
+            ) : viewMode === "month" ? (
+              // Month-view row 2: one column per month, shows abbreviated month name
+              monthBlocks.map((block, index) => {
+                const MIN_DAYS_TO_SHOW_LABEL = 15;
+                const showLabel = block.days >= MIN_DAYS_TO_SHOW_LABEL;
+                const isYearBoundary = index > 0 && block.startDate.getUTCMonth() === 0;
+                return /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: "gantt-tsh-dayCell gantt-tsh-weekCell",
+                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: showLabel ? (() => {
+                      const s = block.startDate.toLocaleString("ru-RU", { month: "long", timeZone: "UTC" });
+                      return s.charAt(0).toUpperCase() + s.slice(1);
+                    })() : "" })
+                  },
+                  `mblock-${index}`
+                );
+              })
+            ) : (
+              // Day-view row 2: individual day numbers (existing code)
+              days.map((day, index) => {
+                const isWeekendDay = isCustomWeekend ? isCustomWeekend(day) : day.getUTCDay() === 0 || day.getUTCDay() === 6;
+                const prevDay = days[index - 1];
+                const isMonthBoundary = index > 0 && prevDay && prevDay.getUTCMonth() !== day.getUTCMonth();
+                const isTodayDate = day.getUTCFullYear() === today.getUTCFullYear() && day.getUTCMonth() === today.getUTCMonth() && day.getUTCDate() === today.getUTCDate();
+                const markerKey = `${day.getUTCFullYear()}-${day.getUTCMonth()}-${day.getUTCDate()}`;
+                const marker = markerByDayKey.get(markerKey);
+                const markerColor = marker?.color;
+                const formattedDate = `${String(day.getUTCDate()).padStart(2, "0")}.${String(day.getUTCMonth() + 1).padStart(2, "0")}.${String(day.getUTCFullYear()).slice(-2)}`;
+                const tooltipText = isTodayDate ? `${formattedDate} \u2014 \u0421\u0435\u0433\u043E\u0434\u043D\u044F` : marker?.name ? `${formattedDate} \u2014 ${marker.name}` : void 0;
+                return /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: `gantt-tsh-dayCell ${isWeekendDay ? "gantt-tsh-weekendDay" : ""} ${isTodayDate ? "gantt-tsh-today" : ""} ${marker && !isTodayDate ? "gantt-tsh-markerDay" : ""} ${tooltipText ? "gantt-tsh-dayCell-tooltipTrigger" : ""}`,
+                    style: markerColor && !isTodayDate ? {
+                      ["--gantt-marker-day-color"]: markerColor
+                    } : void 0,
+                    "aria-label": tooltipText,
+                    onMouseEnter: () => {
+                      if (!tooltipText) return;
+                      onTimelineHover?.({
+                        label: tooltipText,
+                        left: index * dayWidth,
+                        color: isTodayDate ? "#dc2626" : markerColor || "var(--gantt-timeline-marker-color, #dc2626)"
+                      });
+                    },
+                    onMouseLeave: onTimelineHoverEnd,
+                    children: /* @__PURE__ */ jsx("span", { className: "gantt-tsh-dayLabel", children: format(day, "d") })
+                  },
+                  `day-${index}`
+                );
+              })
+            )
+          }
+        )
+      ]
     }
-  }
-  return lines;
-};
-var calculateOrthogonalPath = (from, to) => {
-  const fx = Math.round(from.x);
-  const fy = Math.round(from.y);
-  const tx = Math.round(to.x);
-  const ty = Math.round(to.y);
-  if (fy === ty) {
-    return `M ${fx} ${fy} H ${tx}`;
-  }
-  const C = 2;
-  const goingDown = ty > fy;
-  const goingRight = tx >= fx;
-  const dirY = goingDown ? 1 : -1;
-  const dirX = goingRight ? 1 : -1;
-  if (Math.abs(ty - fy) >= C && Math.abs(tx - fx) >= C) {
-    return [
-      `M ${fx} ${fy}`,
-      `H ${tx - dirX * C}`,
-      `L ${tx} ${fy + dirY * C}`,
-      `V ${ty}`
-    ].join(" ");
-  }
-  return `M ${fx} ${fy} H ${tx} V ${ty}`;
+  );
 };
+var TimeScaleHeader_default = TimeScaleHeader;
+
+// src/components/TaskRow/TaskRow.tsx
+import React2, { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2, useSyncExternalStore } from "react";
+import { createPortal } from "react-dom";
 
 // src/utils/expired.ts
 var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
@@ -4260,21 +4537,245 @@ var useTaskDrag = (options) => {
       }
     }
   };
-};
+};
+
+// src/components/GanttChart/previewStore.ts
+function positionsEqual(left, right) {
+  return left?.left === right?.left && left?.width === right?.width;
+}
+function createTaskPreviewPositionStore() {
+  let positions = /* @__PURE__ */ new Map();
+  const listenersByTaskId = /* @__PURE__ */ new Map();
+  function notify(taskIds) {
+    for (const taskId of taskIds) {
+      const listeners = listenersByTaskId.get(taskId);
+      if (!listeners) continue;
+      for (const listener of listeners) {
+        listener();
+      }
+    }
+  }
+  return {
+    subscribeTask(taskId, listener) {
+      const listeners = listenersByTaskId.get(taskId) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersByTaskId.set(taskId, listeners);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          listenersByTaskId.delete(taskId);
+        }
+      };
+    },
+    getTaskPosition(taskId) {
+      return positions.get(taskId);
+    },
+    setPositions(nextPositions) {
+      const changedTaskIds = /* @__PURE__ */ new Set();
+      const mergedPositions = /* @__PURE__ */ new Map();
+      for (const [taskId, nextPosition] of nextPositions) {
+        const currentPosition = positions.get(taskId);
+        if (positionsEqual(currentPosition, nextPosition)) {
+          if (currentPosition) {
+            mergedPositions.set(taskId, currentPosition);
+          }
+          continue;
+        }
+        changedTaskIds.add(taskId);
+        mergedPositions.set(taskId, {
+          left: nextPosition.left,
+          width: nextPosition.width
+        });
+      }
+      for (const taskId of positions.keys()) {
+        if (!nextPositions.has(taskId)) {
+          changedTaskIds.add(taskId);
+        }
+      }
+      if (changedTaskIds.size === 0) {
+        return;
+      }
+      positions = mergedPositions;
+      notify(changedTaskIds);
+    },
+    clear() {
+      if (positions.size === 0) {
+        return;
+      }
+      const changedTaskIds = new Set(positions.keys());
+      positions = /* @__PURE__ */ new Map();
+      notify(changedTaskIds);
+    }
+  };
+}
+function createActivityPreviewStore() {
+  let overridesByTask = /* @__PURE__ */ new Map();
+  const listenersByTaskId = /* @__PURE__ */ new Map();
+  function notify(taskIds) {
+    for (const taskId of taskIds) {
+      for (const listener of listenersByTaskId.get(taskId) ?? []) {
+        listener();
+      }
+    }
+  }
+  return {
+    subscribeTask(taskId, listener) {
+      const listeners = listenersByTaskId.get(taskId) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersByTaskId.set(taskId, listeners);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          listenersByTaskId.delete(taskId);
+        }
+      };
+    },
+    getTaskOverrides(taskId) {
+      return overridesByTask.get(taskId);
+    },
+    setOverrides(nextOverrides) {
+      const changedTaskIds = new Set(nextOverrides.keys());
+      for (const taskId of overridesByTask.keys()) {
+        changedTaskIds.add(taskId);
+      }
+      if ([...changedTaskIds].every((taskId) => {
+        const current = overridesByTask.get(taskId);
+        const next = nextOverrides.get(taskId);
+        if (!current || !next || current.size !== next.size) return false;
+        return [...next].every(([activityId, delta]) => current.get(activityId) === delta);
+      })) {
+        return;
+      }
+      overridesByTask = new Map([...nextOverrides].map(([taskId, deltas]) => [taskId, new Map(deltas)]));
+      notify(changedTaskIds);
+    },
+    clear() {
+      if (overridesByTask.size === 0) {
+        return;
+      }
+      const changedTaskIds = new Set(overridesByTask.keys());
+      overridesByTask = /* @__PURE__ */ new Map();
+      notify(changedTaskIds);
+    }
+  };
+}
+function createActivityBlockStore() {
+  let blockersByTask = /* @__PURE__ */ new Map();
+  const listenersByTaskId = /* @__PURE__ */ new Map();
+  function notify(taskIds) {
+    for (const taskId of taskIds) {
+      for (const listener of listenersByTaskId.get(taskId) ?? []) {
+        listener();
+      }
+    }
+  }
+  return {
+    subscribeTask(taskId, listener) {
+      const listeners = listenersByTaskId.get(taskId) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersByTaskId.set(taskId, listeners);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          listenersByTaskId.delete(taskId);
+        }
+      };
+    },
+    getTaskBlockers(taskId) {
+      return blockersByTask.get(taskId);
+    },
+    setBlockers(nextBlockers) {
+      const changedTaskIds = new Set(nextBlockers.keys());
+      for (const taskId of blockersByTask.keys()) {
+        changedTaskIds.add(taskId);
+      }
+      if ([...changedTaskIds].every((taskId) => {
+        const current = blockersByTask.get(taskId);
+        const next = nextBlockers.get(taskId);
+        if (!current || !next || current.size !== next.size) return false;
+        return [...next].every((activityId) => current.has(activityId));
+      })) {
+        return;
+      }
+      blockersByTask = new Map([...nextBlockers].map(([taskId, ids]) => [taskId, new Set(ids)]));
+      notify(changedTaskIds);
+    },
+    clear() {
+      if (blockersByTask.size === 0) {
+        return;
+      }
+      const changedTaskIds = new Set(blockersByTask.keys());
+      blockersByTask = /* @__PURE__ */ new Map();
+      notify(changedTaskIds);
+    }
+  };
+}
+var activityOwnerKey = (taskId, activityId) => `${taskId}\0${activityId}`;
+function createActivityDragOwner() {
+  let ownerKey = null;
+  return {
+    get: () => ownerKey,
+    set: (nextOwnerKey) => {
+      ownerKey = nextOwnerKey;
+    }
+  };
+}
+function createActivityActivationStore() {
+  let activeKey = null;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getActiveKey: () => activeKey,
+    setActiveKey(nextKey) {
+      if (activeKey === nextKey) return;
+      activeKey = nextKey;
+      for (const listener of listeners) listener();
+    }
+  };
+}
 
 // src/components/TaskRow/TaskRow.tsx
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var COMPOSITE_SEGMENT_CUT_MIN_PX = 10;
+var toIsoDay = (date) => date.toISOString().slice(0, 10);
+var shiftActivityDay = (value, days) => new Date(parseUTCDate(value).getTime() + days * DAY_MS);
+var activityDurationDays = (activity) => Math.max(1, Math.round((parseUTCDate(activity.endDate).getTime() - parseUTCDate(activity.startDate).getTime()) / DAY_MS) + 1);
+var ACTIVITY_TEXT_LUMINANCE_THRESHOLD = 0.55;
+var relativeLuminance = (hex) => {
+  const channels = [1, 3, 5].map((index) => {
+    const value = parseInt(hex.slice(index, index + 2), 16) / 255;
+    return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * channels[0] + 0.7152 * channels[1] + 0.0722 * channels[2];
+};
+var activityTextColor = (background) => {
+  const lightText = "var(--gantt-task-bar-text-color, #ffffff)";
+  if (!background) return lightText;
+  const value = background.trim();
+  if (value.startsWith("#")) {
+    return relativeLuminance(value) > ACTIVITY_TEXT_LUMINANCE_THRESHOLD ? "#111111" : "#ffffff";
+  }
+  const oklch = /oklch\(\s*([0-9.]+)/i.exec(value);
+  if (oklch) {
+    return Number(oklch[1]) > 0.66 ? "#111111" : "#ffffff";
+  }
+  return lightText;
+};
 var formatCompositePreviewDate = (date) => {
   const month = new Intl.DateTimeFormat("ru-RU", { month: "short", timeZone: "UTC" }).format(date).replace(/\.$/, "");
   const yearSuffix = date.getUTCFullYear() === (/* @__PURE__ */ new Date()).getFullYear() ? "" : ` ${String(date.getUTCFullYear()).slice(-2)}`;
   return `${date.getUTCDate()} ${month}${yearSuffix}`;
 };
 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.baselineStartDate === nextProps.task.baselineStartDate && prevProps.task.baselineEndDate === nextProps.task.baselineEndDate && 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.previewPositionStore === nextProps.previewPositionStore && prevProps.allTasks === nextProps.allTasks && prevProps.disableConstraints === nextProps.disableConstraints && prevProps.deferCascadePreview === nextProps.deferCascadePreview && prevProps.task.locked === nextProps.task.locked && prevProps.task.synced === nextProps.task.synced && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isCritical === nextProps.isCritical && prevProps.showBaseline === nextProps.showBaseline && prevProps.onCompositeToggle === nextProps.onCompositeToggle && prevProps.compactDetail === nextProps.compactDetail && prevProps.compositeParentColor === nextProps.compositeParentColor && prevProps.compositeExpanded === nextProps.compositeExpanded && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag && prevProps.disableDependencyEditing === nextProps.disableDependencyEditing && prevProps.isDependencyDragActive === nextProps.isDependencyDragActive && prevProps.viewMode === nextProps.viewMode && prevProps.showTaskDateLabels === nextProps.showTaskDateLabels && prevProps.showTaskNames === nextProps.showTaskNames && prevProps.showCompositeSegments === nextProps.showCompositeSegments;
+  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.baselineStartDate === nextProps.task.baselineStartDate && prevProps.task.baselineEndDate === nextProps.task.baselineEndDate && 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.task.activities === nextProps.task.activities && 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.previewPositionStore === nextProps.previewPositionStore && prevProps.activityPreviewStore === nextProps.activityPreviewStore && prevProps.activityBlockStore === nextProps.activityBlockStore && prevProps.activityDragOwner === nextProps.activityDragOwner && prevProps.activityActivationStore === nextProps.activityActivationStore && prevProps.activityClickToDrag === nextProps.activityClickToDrag && prevProps.activityActivationMode === nextProps.activityActivationMode && prevProps.showActivityLinks === nextProps.showActivityLinks && prevProps.showActivityLag === nextProps.showActivityLag && prevProps.horizontalWindow?.startPx === nextProps.horizontalWindow?.startPx && prevProps.horizontalWindow?.endPx === nextProps.horizontalWindow?.endPx && prevProps.allTasks === nextProps.allTasks && prevProps.disableConstraints === nextProps.disableConstraints && prevProps.deferCascadePreview === nextProps.deferCascadePreview && prevProps.task.locked === nextProps.task.locked && prevProps.task.synced === nextProps.task.synced && prevProps.task.divider === nextProps.task.divider && prevProps.highlightExpiredTasks === nextProps.highlightExpiredTasks && prevProps.isCritical === nextProps.isCritical && prevProps.showBaseline === nextProps.showBaseline && prevProps.onCompositeToggle === nextProps.onCompositeToggle && prevProps.compactDetail === nextProps.compactDetail && prevProps.compositeParentColor === nextProps.compositeParentColor && prevProps.compositeExpanded === nextProps.compositeExpanded && prevProps.isFilterMatch === nextProps.isFilterMatch && prevProps.businessDays === nextProps.businessDays && prevProps.customDays === nextProps.customDays && prevProps.isWeekend === nextProps.isWeekend && prevProps.disableTaskDrag === nextProps.disableTaskDrag && prevProps.disableDependencyEditing === nextProps.disableDependencyEditing && prevProps.isDependencyDragActive === nextProps.isDependencyDragActive && prevProps.viewMode === nextProps.viewMode && prevProps.showTaskDateLabels === nextProps.showTaskDateLabels && prevProps.showTaskNames === nextProps.showTaskNames && prevProps.showCompositeSegments === nextProps.showCompositeSegments;
 };
 var TaskRow = React2.memo(
-  ({ task, monthStart, dayWidth, rowHeight, onTasksChange, onScheduleIntent, onDragStateChange, rowIndex, allTasks, enableAutoSchedule, disableConstraints, deferCascadePreview = false, overridePosition, previewPositionStore, onCascadeProgress, onCascade, divider, highlightExpiredTasks, isCritical = false, showBaseline = false, isFilterMatch = false, businessDays, customDays, isWeekend: isWeekend3, disableTaskDrag = false, disableDependencyEditing = false, onDependencyPortPointerDown, isDependencyDragActive = false, viewMode = "day", showTaskDateLabels = true, showTaskNames = true, showCompositeSegments: showCompositeSegmentsProp = true, onCompositeToggle, compactDetail = false, compositeParentColor, compositeExpanded = false }) => {
+  ({ task, monthStart, dayWidth, rowHeight, onTasksChange, onScheduleIntent, onDragStateChange, rowIndex, allTasks, enableAutoSchedule, disableConstraints, deferCascadePreview = false, overridePosition, previewPositionStore, activityPreviewStore, activityBlockStore, activityDragOwner, activityActivationStore, activityClickToDrag = false, activityActivationMode = "none", showActivityLinks = true, showActivityLag = true, activityTooltip, horizontalWindow, onCascadeProgress, onCascade, divider, highlightExpiredTasks, isCritical = false, showBaseline = false, isFilterMatch = false, businessDays, customDays, isWeekend: isWeekend3, disableTaskDrag = false, disableDependencyEditing = false, onDependencyPortPointerDown, isDependencyDragActive = false, viewMode = "day", showTaskDateLabels = true, showTaskNames = true, showCompositeSegments: showCompositeSegmentsProp = true, onCompositeToggle, compactDetail = false, compositeParentColor, compositeExpanded = false }) => {
     const defaultParentBarColor = "#782FC4";
     const [showCompositePreview, setShowCompositePreview] = useState2(false);
     const [compositePreviewPosition, setCompositePreviewPosition] = useState2(null);
@@ -4484,6 +4985,347 @@ var TaskRow = React2.memo(
     const shouldRenderCompositeSegments = showCompositeSegmentsProp && task.composite && compositeSegments.length > 0 && visualWidth / compositeSegments.length >= 22;
     const shouldRenderBaseline = showBaseline && baselineGeometry !== null;
     const hasPreviewPosition = isDragging || effectiveOverridePosition !== void 0;
+    const activityLayout = useMemo2(
+      () => task.activities && task.activities.length > 0 ? computeActivityLanes(task.activities, monthStart, dayWidth) : null,
+      [task.activities, monthStart, dayWidth]
+    );
+    const renderActivities = activityLayout !== null && !compactDetail;
+    const activityTopOffset = activityLayout ? Math.max(0, (rowHeight - activityLayout.laneCount * ACTIVITY_LANE_STEP) / 2) : 0;
+    const activityDragEnabled = !task.locked && !disableTaskDrag;
+    const [activityDrag, setActivityDrag] = useState2(null);
+    const [activityTipId, setActivityTipId] = useState2(null);
+    const [activityTipPosition, setActivityTipPosition] = useState2(null);
+    const activityTipAnchor = useRef2(null);
+    const activityDragStart = useRef2(null);
+    const activityConstraintRef = useRef2(null);
+    const [activityBlockedBy, setActivityBlockedBy] = useState2(null);
+    const visibleActivitySegments = useMemo2(() => {
+      if (!activityLayout) return [];
+      const window2 = horizontalWindow;
+      if (!window2) return activityLayout.segments;
+      const draggedId = activityDrag?.id;
+      return activityLayout.segments.filter((segment) => segment.id === draggedId || segment.left <= window2.endPx && segment.left + segment.width >= window2.startPx);
+    }, [activityLayout, horizontalWindow, activityDrag?.id]);
+    const subscribeActivityOverrides = useCallback2(
+      (listener) => activityPreviewStore?.subscribeTask(task.id, listener) ?? (() => {
+      }),
+      [activityPreviewStore, task.id]
+    );
+    const getActivityOverridesSnapshot = useCallback2(
+      () => activityPreviewStore?.getTaskOverrides(task.id),
+      [activityPreviewStore, task.id]
+    );
+    const activityOverrides = useSyncExternalStore(
+      subscribeActivityOverrides,
+      getActivityOverridesSnapshot,
+      () => void 0
+    );
+    const subscribeActivityBlock = useCallback2(
+      (listener) => activityBlockStore?.subscribeTask(task.id, listener) ?? (() => {
+      }),
+      [activityBlockStore, task.id]
+    );
+    const getActivityBlockSnapshot = useCallback2(
+      () => activityBlockStore?.getTaskBlockers(task.id),
+      [activityBlockStore, task.id]
+    );
+    const blockedActivityIds = useSyncExternalStore(
+      subscribeActivityBlock,
+      getActivityBlockSnapshot,
+      () => void 0
+    );
+    const subscribeActivation = useCallback2(
+      (listener) => activityActivationStore?.subscribe(listener) ?? (() => {
+      }),
+      [activityActivationStore]
+    );
+    const getActivationSnapshot = useCallback2(
+      () => activityActivationStore?.getActiveKey() ?? null,
+      [activityActivationStore]
+    );
+    const activeActivityKey = useSyncExternalStore(
+      subscribeActivation,
+      getActivationSnapshot,
+      () => null
+    );
+    const activeWork = useMemo2(() => {
+      if (!activeActivityKey) return null;
+      const [activeTaskId, activeActivityId] = activeActivityKey.split("\0");
+      const source = (allTasks ?? []).find((candidate) => candidate.id === activeTaskId);
+      const activity = source?.activities?.find((candidate) => candidate.id === activeActivityId);
+      return { id: activeActivityId, name: activity?.name ?? null };
+    }, [activeActivityKey, allTasks]);
+    const activationVisualEnabled = activityClickToDrag || activityActivationMode !== "none";
+    const dimOthers = activityActivationMode === "dim";
+    const highlightChain = activityActivationMode === "highlight";
+    const chainEndDeltaDays = (mode, dayDelta, durationDays2) => {
+      if (mode === "resize-left") return 0;
+      if (mode === "resize-right") return Math.max(dayDelta, -(durationDays2 - 1));
+      return dayDelta;
+    };
+    const publishChainPreview = useCallback2((draggedId, mode, dayDelta) => {
+      if (!activityPreviewStore) return;
+      if (!task.activityChain) {
+        activityPreviewStore.clear();
+        return;
+      }
+      let shifts;
+      if (task.activityChain === "push") {
+        let delta = dayDelta;
+        if (mode !== "resize-right") {
+          const minDelta = activityConstraintRef.current?.minStartDelta ?? null;
+          if (minDelta !== null) delta = Math.max(delta, minDelta);
+        }
+        shifts = delta === 0 ? [] : pushActivityChain(allTasks ?? [], task.id, draggedId, delta).shifts;
+      } else {
+        const endDelta = chainEndDeltaDays(mode, dayDelta, activityDragStart.current?.durationDays ?? 1);
+        shifts = endDelta === 0 ? [] : shiftActivityChain(allTasks ?? [], task.id, draggedId, endDelta);
+      }
+      if (shifts.length === 0) {
+        activityPreviewStore.clear();
+        return;
+      }
+      const overrides = /* @__PURE__ */ new Map();
+      for (const shift of shifts) {
+        const deltas = /* @__PURE__ */ new Map();
+        for (const [id, d] of shift.deltas) {
+          if (d !== 0) deltas.set(id, d);
+        }
+        if (deltas.size > 0) overrides.set(shift.taskId, deltas);
+      }
+      activityPreviewStore.setOverrides(overrides);
+    }, [activityPreviewStore, allTasks, task.activityChain, task.id]);
+    useEffect2(() => {
+      if (!activityDrag) return;
+      const startInfo = activityDragStart.current;
+      if (!startInfo) return;
+      const publishBlockers = (blocked) => {
+        const constraint = activityConstraintRef.current;
+        if (!activityBlockStore) return;
+        if (!blocked || !constraint) {
+          activityBlockStore.clear();
+          setActivityBlockedBy((current) => current === null ? current : null);
+          return;
+        }
+        const blockers = /* @__PURE__ */ new Map();
+        const names = [];
+        for (const blocker of constraint.blockers) {
+          const set = blockers.get(blocker.taskId) ?? /* @__PURE__ */ new Set();
+          set.add(blocker.activityId);
+          blockers.set(blocker.taskId, set);
+          const source = (allTasks ?? []).find((candidate) => candidate.id === blocker.taskId);
+          const work = source?.activities?.find((activity) => activity.id === blocker.activityId);
+          const workName = work?.name ?? source?.name ?? blocker.activityId;
+          names.push(blocker.taskId === task.id ? workName : `${source?.name ?? blocker.taskId} \xB7 ${workName}`);
+        }
+        activityBlockStore.setBlockers(blockers);
+        setActivityBlockedBy((current) => current && current.lag === constraint.lag && current.names.length === names.length && current.names.every((name, index) => name === names[index]) ? current : { names, lag: constraint.lag });
+      };
+      const onMove = (event) => {
+        const rawDelta = Math.round((event.clientX - startInfo.x) / dayWidth);
+        let requested = rawDelta;
+        if (activityDrag.mode === "resize-left") requested = Math.min(rawDelta, startInfo.durationDays - 1);
+        if (activityDrag.mode === "resize-right") requested = Math.max(rawDelta, -(startInfo.durationDays - 1));
+        const constraint = activityConstraintRef.current;
+        let clamped = requested;
+        let blocked = false;
+        if (constraint && activityDrag.mode !== "resize-right" && requested < constraint.minStartDelta) {
+          clamped = constraint.minStartDelta;
+          blocked = true;
+        }
+        setActivityDrag((current) => current ? { ...current, dayDelta: clamped } : current);
+        publishBlockers(blocked);
+        const anchor = activityTipAnchor.current;
+        if (anchor) {
+          const shiftPx = activityDrag.mode === "resize-right" ? 0 : clamped * dayWidth;
+          setActivityTipPosition({
+            left: Math.max(8, Math.min(anchor.left + shiftPx, window.innerWidth - 160)),
+            top: anchor.top,
+            below: anchor.below
+          });
+        }
+        publishChainPreview(activityDrag.id, activityDrag.mode, clamped);
+      };
+      const onUp = () => {
+        activityPreviewStore?.clear();
+        activityBlockStore?.clear();
+        activityDragOwner?.set(null);
+        setActivityBlockedBy(null);
+        setActivityTipId(null);
+        activityTipAnchor.current = null;
+        setActivityTipPosition(null);
+        if (activityDrag.dayDelta !== 0) {
+          const chainPush = task.activityChain === "push";
+          let delta = activityDrag.dayDelta;
+          if (chainPush && activityDrag.mode !== "resize-right") {
+            const minDelta = activityConstraintRef.current?.minStartDelta ?? null;
+            if (minDelta !== null) delta = Math.max(delta, minDelta);
+          }
+          const clampLeft = Math.min(delta, startInfo.durationDays - 1);
+          const clampRight = Math.max(delta, -(startInfo.durationDays - 1));
+          const updatedActivities = (task.activities ?? []).map((activity) => {
+            if (activity.id !== activityDrag.id) return activity;
+            if (activityDrag.mode === "move") {
+              return {
+                ...activity,
+                startDate: toIsoDay(shiftActivityDay(activity.startDate, delta)),
+                endDate: toIsoDay(shiftActivityDay(activity.endDate, delta))
+              };
+            }
+            if (activityDrag.mode === "resize-left") {
+              return { ...activity, startDate: toIsoDay(shiftActivityDay(activity.startDate, clampLeft)) };
+            }
+            return { ...activity, endDate: toIsoDay(shiftActivityDay(activity.endDate, clampRight)) };
+          });
+          const chainShifts = chainPush ? delta !== 0 ? pushActivityChain(allTasks ?? [], task.id, activityDrag.id, delta).shifts : [] : (() => {
+            const endDeltaDays = chainEndDeltaDays(activityDrag.mode, delta, startInfo.durationDays);
+            return endDeltaDays !== 0 ? shiftActivityChain(allTasks ?? [], task.id, activityDrag.id, endDeltaDays) : [];
+          })();
+          const changedTasks = [];
+          let hostHandled = false;
+          for (const shift of chainShifts) {
+            if (shift.taskId === task.id) {
+              hostHandled = true;
+              changedTasks.push({
+                ...normalizedTask,
+                activities: shift.activities.map((activity) => activity.id === activityDrag.id ? updatedActivities.find((item) => item.id === activityDrag.id) ?? activity : activity)
+              });
+            } else {
+              const source = (allTasks ?? []).find((candidate) => candidate.id === shift.taskId);
+              changedTasks.push({ ...source ?? { id: shift.taskId }, activities: shift.activities });
+            }
+          }
+          if (!hostHandled) {
+            changedTasks.unshift({ ...normalizedTask, activities: updatedActivities });
+          }
+          onTasksChange?.(changedTasks);
+        }
+        setActivityDrag(null);
+        activityDragStart.current = null;
+        activityConstraintRef.current = null;
+        document.body.style.cursor = "";
+      };
+      document.body.style.cursor = activityDrag.mode === "move" ? "grabbing" : "ew-resize";
+      window.addEventListener("mousemove", onMove);
+      window.addEventListener("mouseup", onUp);
+      return () => {
+        window.removeEventListener("mousemove", onMove);
+        window.removeEventListener("mouseup", onUp);
+        document.body.style.cursor = "";
+      };
+    }, [activityDrag, activityPreviewStore, activityBlockStore, activityDragOwner, allTasks, dayWidth, normalizedTask, onTasksChange, publishChainPreview, task.activities]);
+    const anchorActivityTip = (rect) => {
+      const below = rect.top < 34;
+      const anchor = {
+        left: Math.max(8, Math.min(rect.left, window.innerWidth - 160)),
+        // Вплотную к полосе (1px зазора), сверху или снизу при нехватке места.
+        top: below ? rect.bottom + 1 : rect.top - 1,
+        below
+      };
+      activityTipAnchor.current = anchor;
+      return anchor;
+    };
+    const handleActivityPointerDown = (segment, mode) => (event) => {
+      if (!activityDragEnabled) return;
+      event.preventDefault();
+      event.stopPropagation();
+      activityDragStart.current = {
+        x: event.clientX,
+        durationDays: Math.max(1, Math.round(segment.width / dayWidth) - 1)
+      };
+      activityConstraintRef.current = task.activityChain === "push" && mode !== "resize-right" ? activityStartConstraint(allTasks ?? [], task.id, segment.id) : null;
+      activityDragOwner?.set(activityOwnerKey(task.id, segment.id));
+      setActivityBlockedBy(null);
+      setActivityTipPosition(anchorActivityTip(event.currentTarget.getBoundingClientRect()));
+      setActivityTipId(segment.id);
+      setActivityDrag({ id: segment.id, mode, dayDelta: 0 });
+    };
+    const liveActivityGeometry = (segment) => {
+      if (!activityDrag || activityDrag.id !== segment.id || activityDrag.dayDelta === 0) return segment;
+      if (activityDrag.mode === "move") {
+        return { left: segment.left + activityDrag.dayDelta * dayWidth, width: segment.width };
+      }
+      if (activityDrag.mode === "resize-left") {
+        return { left: segment.left + activityDrag.dayDelta * dayWidth, width: segment.width - activityDrag.dayDelta * dayWidth };
+      }
+      return { left: segment.left, width: segment.width + activityDrag.dayDelta * dayWidth };
+    };
+    const activityLinks = useMemo2(() => {
+      const gaps = [];
+      const elbows = [];
+      if (!showActivityLinks || !renderActivities || !activityLayout) return { gaps, elbows };
+      const activities = task.activities ?? [];
+      const segmentById = new Map(activityLayout.segments.map((segment) => [segment.id, segment]));
+      const visibleIds = new Set(visibleActivitySegments.map((segment) => segment.id));
+      const laneTopY = (lane) => activityTopOffset + lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2;
+      const liveRect = (segment) => {
+        const geometry = liveActivityGeometry(segment);
+        const chainDelta = activityOverrides?.get(segment.id) ?? 0;
+        const left2 = geometry.left + (chainDelta !== 0 ? chainDelta * dayWidth : 0);
+        return { left: left2, right: left2 + geometry.width };
+      };
+      for (let index = 0; index < activities.length - 1; index += 1) {
+        const predecessor = segmentById.get(activities[index].id);
+        const successor = segmentById.get(activities[index + 1].id);
+        if (!predecessor || !successor) continue;
+        if (!visibleIds.has(predecessor.id) || !visibleIds.has(successor.id)) continue;
+        const lag = activities[index + 1].lag ?? 0;
+        const predRect = liveRect(predecessor);
+        const succRect = liveRect(successor);
+        if (predecessor.lane === successor.lane && succRect.left >= predRect.right) {
+          const width2 = succRect.left - predRect.right;
+          if (width2 >= 1) {
+            gaps.push({ key: `${predecessor.id}->${successor.id}`, left: predRect.right, width: width2, lane: predecessor.lane, lag });
+          }
+          continue;
+        }
+        const predecessorLaneTop = laneTopY(predecessor.lane);
+        const successorLaneTop = laneTopY(successor.lane);
+        const sameLane = predecessor.lane === successor.lane;
+        const reverseOrder = !sameLane && successorLaneTop < predecessorLaneTop;
+        const fromY = reverseOrder ? predecessorLaneTop + 6 : predecessorLaneTop + ACTIVITY_LANE_BAR_HEIGHT - 6;
+        const toY = reverseOrder ? successorLaneTop + ACTIVITY_LANE_BAR_HEIGHT - 6 : successorLaneTop + (sameLane ? ACTIVITY_LANE_STEP : 0) + 6;
+        const fromX = predRect.right;
+        const toX = succRect.left;
+        elbows.push({
+          key: `${predecessor.id}->${successor.id}`,
+          d: calculateDependencyPath({ x: fromX, y: fromY }, { x: toX, y: toY }, false),
+          lagX: toX - 14,
+          lagY: reverseOrder ? fromY - 4 : fromY + 12,
+          lag
+        });
+      }
+      return { gaps, elbows };
+    }, [showActivityLinks, renderActivities, activityLayout, visibleActivitySegments, activityTopOffset, activityOverrides, activityDrag, dayWidth, task.activities]);
+    const activityTipData = useMemo2(() => {
+      if (!activityTipId || !task.activities) return null;
+      const activity = task.activities.find((item) => item.id === activityTipId);
+      if (!activity) return null;
+      let startDate = parseUTCDate(activity.startDate);
+      let endDate = parseUTCDate(activity.endDate);
+      if (activityDrag && activityDrag.id === activity.id && activityDrag.dayDelta !== 0) {
+        startDate = shiftActivityDay(startDate, activityDrag.dayDelta);
+        endDate = shiftActivityDay(endDate, activityDrag.dayDelta);
+      }
+      const progress = activity.progress === void 0 ? void 0 : Math.min(100, Math.max(0, Math.round(activity.progress)));
+      return {
+        floor: task.name,
+        name: activity.name,
+        // Готовность — первой строкой подсказки, дальше пользовательские поля.
+        fields: [
+          ...progress !== void 0 ? [{ label: "\u0413\u043E\u0442\u043E\u0432\u043D\u043E\u0441\u0442\u044C", value: `${progress}%` }] : [],
+          ...activity.tooltipFields ?? []
+        ],
+        context: {
+          task,
+          activity,
+          startDate,
+          endDate,
+          durationDays: activityDurationDays({ startDate, endDate }),
+          progress
+        }
+      };
+    }, [activityDrag, activityTipId, task, task.activities, task.name]);
     const currentStartDate = hasPreviewPosition ? pixelsToDate(displayLeft, monthStart, dayWidth) : taskStartDate;
     const currentEndDate = hasPreviewPosition ? milestone ? pixelsToDate(displayLeft, monthStart, dayWidth) : pixelsToDate(displayLeft + displayWidth - dayWidth, monthStart, dayWidth) : taskEndDate;
     const dateRangeLabel = formatDateRangeLabel(currentStartDate, currentEndDate);
@@ -4516,7 +5358,7 @@ var TaskRow = React2.memo(
         children: [
           taskDivider === "top" && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-divider gantt-tr-divider-top" }),
           /* @__PURE__ */ jsxs2("div", { className: "gantt-tr-taskContainer", children: [
-            shouldRenderBaseline && /* @__PURE__ */ jsx2(
+            shouldRenderBaseline && !renderActivities && /* @__PURE__ */ jsx2(
               "div",
               {
                 className: `gantt-tr-baseline ${isParent ? "gantt-tr-baseline-parent" : ""} ${milestone ? "gantt-tr-baseline-milestone" : ""}`,
@@ -4526,7 +5368,122 @@ var TaskRow = React2.memo(
                 }
               }
             ),
-            /* @__PURE__ */ jsxs2(
+            renderActivities && activityLayout && /* @__PURE__ */ jsxs2("div", { className: "gantt-tr-activityLanes", children: [
+              activityLinks.elbows.length > 0 && /* @__PURE__ */ jsxs2("svg", { className: "gantt-tr-activityLinksSvg", width: "100%", height: "100%", "aria-hidden": "true", children: [
+                /* @__PURE__ */ jsx2("defs", { children: /* @__PURE__ */ jsx2("marker", { id: "arrowhead", markerWidth: "8", markerHeight: "6", markerUnits: "userSpaceOnUse", refX: "7", refY: "3", orient: "auto", children: /* @__PURE__ */ jsx2("polygon", { points: "0 0, 8 3, 0 6", fill: "var(--gantt-dependency-line-color, #666666)" }) }) }),
+                activityLinks.elbows.map((link) => /* @__PURE__ */ jsxs2("g", { children: [
+                  /* @__PURE__ */ jsx2("path", { className: "gantt-dependency-path", d: link.d, markerEnd: "url(#arrowhead)" }),
+                  showActivityLag && link.lag !== 0 && /* @__PURE__ */ jsx2(
+                    "text",
+                    {
+                      className: "gantt-dependency-lag-label",
+                      x: link.lagX,
+                      y: link.lagY,
+                      textAnchor: "middle",
+                      fontSize: "10",
+                      fill: "var(--gantt-dependency-line-color, #666666)",
+                      children: link.lag > 0 ? `+${link.lag}` : `${link.lag}`
+                    }
+                  )
+                ] }, link.key))
+              ] }),
+              visibleActivitySegments.map((segment) => {
+                const live = liveActivityGeometry(segment);
+                const chainDelta = activityOverrides?.get(segment.id) ?? 0;
+                const activityProgress = segment.progress === void 0 ? 0 : Math.min(100, Math.max(0, Math.round(segment.progress)));
+                const liveLeft = live.left + (chainDelta !== 0 ? chainDelta * dayWidth : 0);
+                const isDraggingActivity = activityDrag?.id === segment.id;
+                const isBlockingActivity = blockedActivityIds?.has(segment.id) ?? false;
+                const isAtLimit = isDraggingActivity && activityBlockedBy !== null;
+                const isActiveActivity = activationVisualEnabled && activeActivityKey === activityOwnerKey(task.id, segment.id);
+                const isSameWorkType = activeWork !== null && (segment.id === activeWork.id || activeWork.name !== null && segment.name === activeWork.name);
+                const isDimmed = dimOthers && activeWork !== null && !isSameWorkType;
+                const isChainHighlighted = highlightChain && activeWork !== null && isSameWorkType;
+                return /* @__PURE__ */ jsxs2(
+                  "div",
+                  {
+                    "data-activity-id": segment.id,
+                    className: `gantt-tr-activityBar${isDraggingActivity ? " gantt-tr-activityBar-dragging" : ""}${isBlockingActivity ? " gantt-tr-activityBar-blocking" : ""}${isAtLimit ? " gantt-tr-activityBar-atLimit" : ""}${isActiveActivity ? " gantt-tr-activityBar-active" : ""}${isDimmed ? " gantt-tr-activityBar-dimmed" : ""}${isChainHighlighted ? " gantt-tr-activityBar-chain" : ""}${activityDragEnabled ? "" : " gantt-tr-activityBar-locked"}`,
+                    style: {
+                      left: `${liveLeft}px`,
+                      width: `${live.width}px`,
+                      top: `${activityTopOffset + segment.lane * ACTIVITY_LANE_STEP + (ACTIVITY_LANE_STEP - ACTIVITY_LANE_BAR_HEIGHT) / 2}px`,
+                      height: `${ACTIVITY_LANE_BAR_HEIGHT}px`,
+                      backgroundColor: segment.color || "var(--gantt-task-bar-default-color)"
+                    },
+                    onMouseDown: (event) => {
+                      if (!activityDragEnabled) return;
+                      const activationKey = activityOwnerKey(task.id, segment.id);
+                      const isActive = activityActivationStore?.getActiveKey() === activationKey;
+                      if (activationVisualEnabled && !isActive) {
+                        activityActivationStore?.setActiveKey(activationKey);
+                      }
+                      if (activityClickToDrag && !isActive) return;
+                      const target = event.target;
+                      const mode = target.closest(".gantt-tr-resizeHandleLeft") ? "resize-left" : target.closest(".gantt-tr-resizeHandleRight") ? "resize-right" : "move";
+                      handleActivityPointerDown(segment, mode)(event);
+                    },
+                    onMouseEnter: (event) => {
+                      if (activityDrag || activityDragOwner?.get()) return;
+                      setActivityTipPosition(anchorActivityTip(event.currentTarget.getBoundingClientRect()));
+                      setActivityTipId(segment.id);
+                    },
+                    onMouseLeave: () => {
+                      if (!activityDrag) {
+                        setActivityTipId((current) => current === segment.id ? null : current);
+                        activityTipAnchor.current = null;
+                        setActivityTipPosition(null);
+                      }
+                    },
+                    children: [
+                      activityProgress > 0 && /* @__PURE__ */ jsx2(
+                        "span",
+                        {
+                          className: "gantt-tr-activityProgress",
+                          style: { width: `${activityProgress}%` }
+                        }
+                      ),
+                      /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityName", style: { color: activityTextColor(segment.color) }, children: segment.name }),
+                      activityDragEnabled && /* @__PURE__ */ jsxs2(Fragment, { children: [
+                        /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
+                        /* @__PURE__ */ jsx2("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
+                      ] })
+                    ]
+                  },
+                  segment.id
+                );
+              }),
+              activityLinks.gaps.map((gap) => /* @__PURE__ */ jsxs2(React2.Fragment, { children: [
+                /* @__PURE__ */ jsx2(
+                  "span",
+                  {
+                    className: "gantt-tr-activityLink",
+                    "aria-hidden": "true",
+                    style: {
+                      left: `${gap.left}px`,
+                      width: `${gap.width}px`,
+                      top: `${activityTopOffset + gap.lane * ACTIVITY_LANE_STEP + ACTIVITY_LANE_STEP / 2}px`
+                    }
+                  }
+                ),
+                showActivityLag && gap.lag > 0 && /* @__PURE__ */ jsxs2(
+                  "span",
+                  {
+                    className: "gantt-tr-activityLag",
+                    title: `\u0417\u0430\u0437\u043E\u0440 ${gap.lag} \u0434`,
+                    style: {
+                      left: `${gap.left + gap.width - 14}px`,
+                      top: `${activityTopOffset + gap.lane * ACTIVITY_LANE_STEP + ACTIVITY_LANE_STEP / 2}px`
+                    },
+                    children: [
+                      "+",
+                      gap.lag
+                    ]
+                  }
+                )
+              ] }, gap.key))
+            ] }),
+            !renderActivities && /* @__PURE__ */ jsxs2(
               "div",
               {
                 "data-taskbar": true,
@@ -4682,7 +5639,33 @@ var TaskRow = React2.memo(
               ),
               document.body
             ),
-            !disableDependencyEditing && onDependencyPortPointerDown && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            activityTipData && activityTipPosition && typeof document !== "undefined" && createPortal(
+              /* @__PURE__ */ jsxs2(
+                "div",
+                {
+                  className: `gantt-tr-activityTip${activityTipPosition.below ? " gantt-tr-activityTip-below" : ""}`,
+                  style: { left: `${activityTipPosition.left}px`, top: `${activityTipPosition.top}px` },
+                  role: "tooltip",
+                  children: [
+                    /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityTipName", children: activityTipData.floor }),
+                    /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityTipDot", "aria-hidden": "true", children: "\xB7" }),
+                    /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityTipWork", children: activityTipData.name }),
+                    activityTooltip && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-activityTipExtra", children: activityTooltip(activityTipData.context) }),
+                    activityTipData.fields.length > 0 && /* @__PURE__ */ jsx2("div", { className: "gantt-tr-activityTipFields", children: activityTipData.fields.map((field) => /* @__PURE__ */ jsxs2("div", { className: "gantt-tr-activityTipField", children: [
+                      /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityTipFieldLabel", children: field.label }),
+                      /* @__PURE__ */ jsx2("span", { className: "gantt-tr-activityTipFieldValue", children: field.value })
+                    ] }, field.label)) }),
+                    activityBlockedBy && /* @__PURE__ */ jsxs2("span", { className: "gantt-tr-activityTipReason", children: [
+                      "\xB7 \u0411\u043B\u043E\u043A: ",
+                      activityBlockedBy.names.join(", "),
+                      activityBlockedBy.lag > 0 ? ` \xB7 \u0437\u0430\u0437\u043E\u0440 ${activityBlockedBy.lag} \u0434` : ""
+                    ] })
+                  ]
+                }
+              ),
+              document.body
+            ),
+            !disableDependencyEditing && onDependencyPortPointerDown && !renderActivities && /* @__PURE__ */ jsxs2(Fragment, { children: [
               /* @__PURE__ */ jsx2(
                 "button",
                 {
@@ -4712,7 +5695,7 @@ var TaskRow = React2.memo(
                 }
               )
             ] }),
-            showTaskDateLabels && /* @__PURE__ */ jsx2(
+            showTaskDateLabels && !renderActivities && /* @__PURE__ */ jsx2(
               "div",
               {
                 className: `gantt-tr-leftLabels ${task.locked ? "gantt-tr-leftLabels-locked" : ""}`,
@@ -4722,7 +5705,7 @@ var TaskRow = React2.memo(
                 children: /* @__PURE__ */ jsx2("span", { className: "gantt-tr-dateLabel gantt-tr-dateLabelLeft", children: dateRangeLabel })
               }
             ),
-            task.locked && /* @__PURE__ */ jsx2(
+            task.locked && !renderActivities && /* @__PURE__ */ jsx2(
               "svg",
               {
                 className: "gantt-tr-lockIcon",
@@ -4743,15 +5726,15 @@ var TaskRow = React2.memo(
                 children: /* @__PURE__ */ jsx2("path", { d: "M18 8h-1V6c0-2.76-2.24-5-5-5S7 3.24 7 6v2H6c-1.1 0-2 .9-2 2v10c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V10c0-1.1-.9-2-2-2zM12 17c-1.1 0-2-.9-2-2s.9-2 2-2 2 .9 2 2-.9 2-2 2zm3.1-9H8.9V6c0-1.71 1.39-3.1 3.1-3.1 1.71 0 3.1 1.39 3.1 3.1v2z" })
               }
             ),
-            !showDurationInside && !milestone && /* @__PURE__ */ jsx2(
+            compactDetail && !milestone && /* @__PURE__ */ jsx2(
               "span",
               {
-                className: `gantt-tr-externalDuration gantt-tr-durationBeforeBar${compactDetail ? " gantt-tr-compositeDuration" : ""}`,
+                className: "gantt-tr-externalDuration gantt-tr-durationBeforeBar gantt-tr-compositeDuration",
                 style: { left: `${visualLeft - 46}px`, color: isParent ? task.color || defaultParentBarColor : barColor },
                 children: isVisualParent ? getChildCountLabel(childCount) : `${durationDays} \u0434`
               }
             ),
-            /* @__PURE__ */ jsxs2(
+            !renderActivities && /* @__PURE__ */ jsxs2(
               "div",
               {
                 className: "gantt-tr-rightLabels",
@@ -4760,6 +5743,7 @@ var TaskRow = React2.memo(
                   color: isParent ? task.color || defaultParentBarColor : barColor
                 },
                 children: [
+                  !compactDetail && !showDurationInside && !milestone && /* @__PURE__ */ jsx2("span", { className: "gantt-tr-externalDuration", children: isVisualParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && !showProgressInside && /* @__PURE__ */ jsxs2("span", { className: "gantt-tr-externalProgress", children: [
                     progressWidth,
                     "%"
@@ -4887,10 +5871,10 @@ import React5, { useMemo as useMemo5 } from "react";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 var arePropsEqual2 = (prevProps, nextProps) => {
   return prevProps.dayWidth === nextProps.dayWidth && prevProps.dateRange.length === nextProps.dateRange.length && prevProps.totalHeight === nextProps.totalHeight && // skip re-render only when totalHeight unchanged
-  prevProps.viewMode === nextProps.viewMode && prevProps.isCustomWeekend === nextProps.isCustomWeekend;
+  prevProps.viewMode === nextProps.viewMode && prevProps.isCustomWeekend === nextProps.isCustomWeekend && prevProps.showWeekendBlocks === nextProps.showWeekendBlocks && prevProps.showGridLines === nextProps.showGridLines && prevProps.horizontalWindow?.startPx === nextProps.horizontalWindow?.startPx && prevProps.horizontalWindow?.endPx === nextProps.horizontalWindow?.endPx;
 };
 var GridBackground = React5.memo(
-  ({ dateRange, dayWidth, totalHeight, viewMode = "day", isCustomWeekend, className, showWeekendBlocks = true, showGridLines = true }) => {
+  ({ dateRange, dayWidth, totalHeight, viewMode = "day", isCustomWeekend, className, showWeekendBlocks = true, showGridLines = true, horizontalWindow }) => {
     const weekGridLines = useMemo5(() => {
       if (viewMode !== "week") return [];
       return calculateWeekGridLines(dateRange, dayWidth);
@@ -4907,6 +5891,23 @@ var GridBackground = React5.memo(
       if (viewMode === "week" || viewMode === "month") return [];
       return calculateWeekendBlocks(dateRange, dayWidth, isCustomWeekend);
     }, [dateRange, dayWidth, viewMode, isCustomWeekend]);
+    const inHorizontalWindow = (left, width = 1) => !horizontalWindow || left <= horizontalWindow.endPx && left + width >= horizontalWindow.startPx;
+    const visibleWeekendBlocks = useMemo5(
+      () => weekendBlocks.filter((block) => inHorizontalWindow(block.left, block.width)),
+      [weekendBlocks, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleWeekGridLines = useMemo5(
+      () => weekGridLines.filter((line) => inHorizontalWindow(line.x)),
+      [weekGridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleMonthGridLines = useMemo5(
+      () => monthGridLines.filter((line) => inHorizontalWindow(line.x)),
+      [monthGridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleGridLines = useMemo5(
+      () => gridLines.filter((line) => inHorizontalWindow(line.x)),
+      [gridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
     const gridWidth = useMemo5(() => {
       return Math.round(dateRange.length * dayWidth);
     }, [dateRange.length, dayWidth]);
@@ -4919,7 +5920,7 @@ var GridBackground = React5.memo(
           height: `${totalHeight}px`
         },
         children: [
-          showWeekendBlocks && weekendBlocks.map((block, index) => /* @__PURE__ */ jsx5(
+          showWeekendBlocks && visibleWeekendBlocks.map((block, index) => /* @__PURE__ */ jsx5(
             "div",
             {
               className: "gantt-gb-weekendBlock",
@@ -4932,7 +5933,7 @@ var GridBackground = React5.memo(
           )),
           showGridLines && (viewMode === "week" ? (
             // Week-view: one line per week column boundary
-            weekGridLines.map((line, index) => {
+            visibleWeekGridLines.map((line, index) => {
               const lineClass = line.isMonthStart ? "gantt-gb-monthSeparator" : "gantt-gb-weekSeparator";
               return /* @__PURE__ */ jsx5(
                 "div",
@@ -4945,7 +5946,7 @@ var GridBackground = React5.memo(
             })
           ) : viewMode === "month" ? (
             // Month-view: thin line at each month boundary, thick at year boundary
-            monthGridLines.map((line, index) => {
+            visibleMonthGridLines.map((line, index) => {
               const lineClass = line.isMonthStart ? "gantt-gb-monthSeparator" : "gantt-gb-weekSeparator";
               return /* @__PURE__ */ jsx5(
                 "div",
@@ -4957,8 +5958,8 @@ var GridBackground = React5.memo(
               );
             })
           ) : (
-            // Day-view: existing code (unchanged)
-            gridLines.map((line, index) => {
+            // Day-view: render only the lines inside the horizontal window.
+            visibleGridLines.map((line, index) => {
               const lineClass = line.isMonthStart ? "gantt-gb-monthSeparator" : line.isWeekStart ? "gantt-gb-weekSeparator" : "gantt-gb-dayLine";
               return /* @__PURE__ */ jsx5(
                 "div",
@@ -5070,7 +6071,8 @@ var DependencyLines = React6.memo(({
   criticalTaskIds,
   businessDays = true,
   weekendPredicate,
-  onDependencyClick
+  onDependencyClick,
+  horizontalWindow
 }) => {
   const [hoveredLineId, setHoveredLineId] = useState3(null);
   const tasksForPositions = allTasks ?? tasks;
@@ -5234,6 +6236,10 @@ var DependencyLines = React6.memo(({
     }
     return lines2;
   }, [tasks, allTasks, taskPositions, taskIndices, cycleInfo, collapsedParentIds, criticalTaskIds]);
+  const visibleLines = useMemo6(() => {
+    if (!horizontalWindow) return lines;
+    return lines.filter((line) => Math.max(line.fromX, line.toX) >= horizontalWindow.startPx && Math.min(line.fromX, line.toX) <= horizontalWindow.endPx);
+  }, [lines, horizontalWindow?.startPx, horizontalWindow?.endPx]);
   const svgHeight = totalHeight ?? tasks.length * rowHeight;
   return /* @__PURE__ */ jsxs5(
     "svg",
@@ -5341,7 +6347,7 @@ var DependencyLines = React6.memo(({
             }
           )
         ] }),
-        lines.map(({ id, predecessorId, successorId, linkType, path, hasCycle, lag, fromX, toX, fromY, reverseOrder, isVirtual, isCritical }) => {
+        visibleLines.map(({ id, predecessorId, successorId, linkType, path, hasCycle, lag, fromX, toX, fromY, reverseOrder, isVirtual, isCritical }) => {
           const isHovered = hoveredLineId === id;
           const isSelected = selectedDep != null && id === `${selectedDep.predecessorId}-${selectedDep.successorId}-${selectedDep.linkType}`;
           let pathClassName = "gantt-dependency-path";
@@ -6205,7 +7211,7 @@ var LINK_TYPE_LABELS = {
 };
 
 // src/components/TaskList/defaultTaskDates.ts
-var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var DAY_MS3 = 24 * 60 * 60 * 1e3;
 var DEFAULT_TASK_DURATION_DAYS = 5;
 function toISODate(date) {
   return date.toISOString().split("T")[0];
@@ -6234,25 +7240,25 @@ function buildDefaultTaskDateRange(startDate, {
   }
   return {
     startDate: toISODate(start),
-    endDate: toISODate(new Date(start.getTime() + (durationDays - 1) * DAY_MS2))
+    endDate: toISODate(new Date(start.getTime() + (durationDays - 1) * DAY_MS3))
   };
 }
 
 // src/components/TaskList/TaskListRow.tsx
 import { Fragment as Fragment3, jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
-var DAY_MS3 = 24 * 60 * 60 * 1e3;
+var DAY_MS4 = 24 * 60 * 60 * 1e3;
 var LINK_TYPE_ORDER = ["FS", "SS", "FF", "SF"];
 var getInclusiveDurationDays = (startDate, endDate) => {
   const start = parseUTCDate(startDate);
   const end = parseUTCDate(endDate);
   return Math.max(
     1,
-    Math.round((end.getTime() - start.getTime()) / DAY_MS3) + 1
+    Math.round((end.getTime() - start.getTime()) / DAY_MS4) + 1
   );
 };
 var getEndDateFromDuration = (startDate, durationDays) => {
   const start = parseUTCDate(startDate);
-  return new Date(start.getTime() + (durationDays - 1) * DAY_MS3).toISOString().split("T")[0];
+  return new Date(start.getTime() + (durationDays - 1) * DAY_MS4).toISOString().split("T")[0];
 };
 var TrashIcon = () => /* @__PURE__ */ jsxs10(
   "svg",
@@ -10358,7 +11364,11 @@ var TaskList = ({
                         onActiveCustomCellChange: setActiveCustomCell,
                         taskListMenuCommands,
                         hideTaskListRowActions,
-                        rowClassName: [task.parentId && compositeParentIds.has(task.parentId) ? "gantt-tl-row-composite-detail" : "", getTaskListRowClassName?.(task)].filter(Boolean).join(" "),
+                        rowClassName: [
+                          task.parentId && compositeParentIds.has(task.parentId) ? "gantt-tl-row-composite-detail" : "",
+                          (task.activities?.length ?? 0) > 0 && (rowHeights?.[index] ?? rowHeight) > rowHeight ? "gantt-tl-row-activities" : "",
+                          getTaskListRowClassName?.(task)
+                        ].filter(Boolean).join(" "),
                         compositeParentColor: task.parentId ? compositeParentsById.get(task.parentId)?.color : void 0,
                         getTaskListNamePrefixIcon,
                         taskDateChangeMode,
@@ -12336,7 +13346,7 @@ import { useLayoutEffect, useMemo as useMemo11, useRef as useRef11, useState as
 import { jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
 var AUTO_COLUMN_MIN_WIDTH = 72;
 var AUTO_COLUMN_MAX_WIDTH = 180;
-var DAY_MS4 = 24 * 60 * 60 * 1e3;
+var DAY_MS5 = 24 * 60 * 60 * 1e3;
 function joinClasses(...values) {
   return values.filter(Boolean).join(" ");
 }
@@ -12371,8 +13381,8 @@ function getOverlayWidthPercent(column, overlayDateMs) {
   if (overlayDateMs >= endMs) {
     return 100;
   }
-  const totalDays = Math.max(1, Math.round((endMs - startMs) / DAY_MS4) + 1);
-  const elapsedDays = Math.min(totalDays, Math.max(0, Math.round((overlayDateMs - startMs) / DAY_MS4) + 1));
+  const totalDays = Math.max(1, Math.round((endMs - startMs) / DAY_MS5) + 1);
+  const elapsedDays = Math.min(totalDays, Math.max(0, Math.round((overlayDateMs - startMs) / DAY_MS5) + 1));
   return elapsedDays / totalDays * 100;
 }
 function isOverlayDateInColumn(column, overlayDateMs) {
@@ -12702,7 +13712,7 @@ function TableMatrix({
 // src/components/PlanFactMatrix/PlanFactMatrix.tsx
 import React16, { useCallback as useCallback9, useEffect as useEffect10, useMemo as useMemo12, useRef as useRef12, useState as useState12 } from "react";
 import { jsx as jsx20, jsxs as jsxs15 } from "react/jsx-runtime";
-var DAY_MS5 = 24 * 60 * 60 * 1e3;
+var DAY_MS6 = 24 * 60 * 60 * 1e3;
 function joinClasses2(...values) {
   return values.filter(Boolean).join(" ");
 }
@@ -12732,8 +13742,8 @@ function getPlannedIndexRange(task, rangeStartMs, rangeLength) {
   if (rangeLength <= 0) return null;
   const start = parseUTCDate(task.startDate);
   const end = parseUTCDate(task.endDate);
-  const startIndex = Math.ceil((getDateOnlyMs(start) - rangeStartMs) / DAY_MS5);
-  const endIndex = Math.floor((getDateOnlyMs(end) - rangeStartMs) / DAY_MS5);
+  const startIndex = Math.ceil((getDateOnlyMs(start) - rangeStartMs) / DAY_MS6);
+  const endIndex = Math.floor((getDateOnlyMs(end) - rangeStartMs) / DAY_MS6);
   const clampedStartIndex = Math.max(0, startIndex);
   const clampedEndIndex = Math.min(rangeLength - 1, endIndex);
   if (clampedStartIndex > clampedEndIndex) return null;
@@ -14102,80 +15112,13 @@ async function printGanttChart({
   }
 }
 
-// src/components/GanttChart/previewStore.ts
-function positionsEqual(left, right) {
-  return left?.left === right?.left && left?.width === right?.width;
-}
-function createTaskPreviewPositionStore() {
-  let positions = /* @__PURE__ */ new Map();
-  const listenersByTaskId = /* @__PURE__ */ new Map();
-  function notify(taskIds) {
-    for (const taskId of taskIds) {
-      const listeners = listenersByTaskId.get(taskId);
-      if (!listeners) continue;
-      for (const listener of listeners) {
-        listener();
-      }
-    }
-  }
-  return {
-    subscribeTask(taskId, listener) {
-      const listeners = listenersByTaskId.get(taskId) ?? /* @__PURE__ */ new Set();
-      listeners.add(listener);
-      listenersByTaskId.set(taskId, listeners);
-      return () => {
-        listeners.delete(listener);
-        if (listeners.size === 0) {
-          listenersByTaskId.delete(taskId);
-        }
-      };
-    },
-    getTaskPosition(taskId) {
-      return positions.get(taskId);
-    },
-    setPositions(nextPositions) {
-      const changedTaskIds = /* @__PURE__ */ new Set();
-      const mergedPositions = /* @__PURE__ */ new Map();
-      for (const [taskId, nextPosition] of nextPositions) {
-        const currentPosition = positions.get(taskId);
-        if (positionsEqual(currentPosition, nextPosition)) {
-          if (currentPosition) {
-            mergedPositions.set(taskId, currentPosition);
-          }
-          continue;
-        }
-        changedTaskIds.add(taskId);
-        mergedPositions.set(taskId, {
-          left: nextPosition.left,
-          width: nextPosition.width
-        });
-      }
-      for (const taskId of positions.keys()) {
-        if (!nextPositions.has(taskId)) {
-          changedTaskIds.add(taskId);
-        }
-      }
-      if (changedTaskIds.size === 0) {
-        return;
-      }
-      positions = mergedPositions;
-      notify(changedTaskIds);
-    },
-    clear() {
-      if (positions.size === 0) {
-        return;
-      }
-      const changedTaskIds = new Set(positions.keys());
-      positions = /* @__PURE__ */ new Map();
-      notify(changedTaskIds);
-    }
-  };
-}
-
 // src/components/GanttChart/GanttChart.tsx
 import { Fragment as Fragment6, jsx as jsx21, jsxs as jsxs16 } from "react/jsx-runtime";
 var SCROLL_TO_ROW_CONTEXT_ROWS = 2;
 var TASK_ROW_OVERSCAN = 8;
+var SCROLL_TOP_BUCKET_PX = 64;
+var HORIZONTAL_WINDOW_BUCKET_PX = 480;
+var HORIZONTAL_WINDOW_OVERSCAN_PX = 960;
 var PLAN_FACT_COLUMN_OVERSCAN = 24;
 var PLAN_FACT_COLUMN_WINDOW_STEP = 14;
 var DEFAULT_INITIAL_VIEWPORT_HEIGHT = 768;
@@ -14369,6 +15312,11 @@ function TaskGanttChartInner(props, ref) {
     showTaskDateLabels = true,
     showTaskNames = true,
     showCompositeSegments = true,
+    activityClickToDrag = false,
+    activityActivationMode = "none",
+    showActivityLinks = true,
+    showActivityLag = true,
+    activityTooltip,
     timelineMarkers,
     additionalColumns,
     hiddenTaskListColumns,
@@ -14402,17 +15350,41 @@ function TaskGanttChartInner(props, ref) {
   const clearSelectedTaskTimeoutRef = useRef13(null);
   const hasAutoScrolledToTodayRef = useRef13(false);
   const previewPositionStoreRef = useRef13(null);
+  const activityPreviewStoreRef = useRef13(null);
+  const activityBlockStoreRef = useRef13(null);
+  const activityDragOwnerRef = useRef13(null);
+  const activityActivationStoreRef = useRef13(null);
   const renderedTaskIdsRef = useRef13(/* @__PURE__ */ new Set());
   if (previewPositionStoreRef.current === null) {
     previewPositionStoreRef.current = createTaskPreviewPositionStore();
   }
+  if (activityPreviewStoreRef.current === null) {
+    activityPreviewStoreRef.current = createActivityPreviewStore();
+  }
+  if (activityBlockStoreRef.current === null) {
+    activityBlockStoreRef.current = createActivityBlockStore();
+  }
+  if (activityDragOwnerRef.current === null) {
+    activityDragOwnerRef.current = createActivityDragOwner();
+  }
+  if (activityActivationStoreRef.current === null) {
+    activityActivationStoreRef.current = createActivityActivationStore();
+  }
   const previewPositionStore = previewPositionStoreRef.current;
+  const activityPreviewStore = activityPreviewStoreRef.current;
+  const activityBlockStore = activityBlockStoreRef.current;
+  const activityDragOwner = activityDragOwnerRef.current;
+  const activityActivationStore = activityActivationStoreRef.current;
   const [selectedTaskId, setSelectedTaskId] = useState13(null);
   const [taskListHasRightShadow, setTaskListHasRightShadow] = useState13(false);
   const [internalTaskDateChangeMode, setInternalTaskDateChangeMode] = useState13("preserve-duration");
   const [scrollViewport, setScrollViewport] = useState13(() => ({
     scrollTop: 0,
-    viewportHeight: getInitialScrollViewportHeight(containerHeight, headerHeight + 1)
+    viewportHeight: getInitialScrollViewportHeight(containerHeight, headerHeight + 1),
+    // Ширина видимой области графика и «бакетированный» горизонтальный скролл —
+    // основа горизонтального окна рендера (см. horizontalWindow).
+    viewportWidth: 0,
+    chartScrollLeft: 0
   }));
   const [forceFullRenderForPrint, setForceFullRenderForPrint] = useState13(false);
   const [planFactDateWindow, setPlanFactDateWindow] = useState13({ start: 0, end: 0 });
@@ -14650,14 +15622,21 @@ function TaskGanttChartInner(props, ref) {
     if (isPlanFactMode) {
       return getPlanFactRangeTasks(normalizedTasks);
     }
-    if (!showBaseline) {
-      return normalizedTasks;
+    const rangeTasks = [];
+    for (const task of normalizedTasks) {
+      if (showBaseline) {
+        rangeTasks.push({
+          startDate: task.baselineStartDate && parseUTCDate(task.baselineStartDate).getTime() < parseUTCDate(task.startDate).getTime() ? task.baselineStartDate : task.startDate,
+          endDate: task.baselineEndDate && parseUTCDate(task.baselineEndDate).getTime() > parseUTCDate(task.endDate).getTime() ? task.baselineEndDate : task.endDate
+        });
+      } else {
+        rangeTasks.push(task);
+      }
+      for (const activity of task.activities ?? []) {
+        rangeTasks.push({ startDate: activity.startDate, endDate: activity.endDate });
+      }
     }
-    return normalizedTasks.map((task) => ({
-      ...task,
-      startDate: task.baselineStartDate && parseUTCDate(task.baselineStartDate).getTime() < parseUTCDate(task.startDate).getTime() ? task.baselineStartDate : task.startDate,
-      endDate: task.baselineEndDate && parseUTCDate(task.baselineEndDate).getTime() > parseUTCDate(task.endDate).getTime() ? task.baselineEndDate : task.endDate
-    }));
+    return rangeTasks;
   }, [isPlanFactMode, normalizedTasks, showBaseline]);
   const dateRange = useMemo13(
     () => {
@@ -14702,6 +15681,25 @@ function TaskGanttChartInner(props, ref) {
     }
     return tasks2;
   }, [normalizedTasks, collapsedParentIds, filterMode, taskFilter, criticalPathMode, criticalTaskIds]);
+  const monthStart = useMemo13(() => {
+    if (dateRange.length === 0) {
+      return new Date(Date.UTC((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth(), 1));
+    }
+    const firstDay = dateRange[0];
+    if (explicitDateRange && !isPlanFactMode) {
+      return new Date(firstDay);
+    }
+    return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
+  }, [dateRange, explicitDateRange, isPlanFactMode]);
+  const activityLaneCounts = useMemo13(() => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const task of visibleTasks) {
+      if (task.activities && task.activities.length > 0) {
+        counts.set(task.id, computeActivityLanes(task.activities, monthStart, dayWidth).laneCount);
+      }
+    }
+    return counts;
+  }, [visibleTasks, monthStart, dayWidth]);
   const compositeRowLayout = useMemo13(() => {
     const compositeIds = new Set(normalizedTasks.filter((task) => task.composite).map((task) => task.id));
     const tops = [];
@@ -14709,12 +15707,12 @@ function TaskGanttChartInner(props, ref) {
     let top = 0;
     for (const task of visibleTasks) {
       tops.push(top);
-      const height = task.parentId && compositeIds.has(task.parentId) ? Math.min(effectiveRowHeight, 22) : effectiveRowHeight;
+      const height = task.parentId && compositeIds.has(task.parentId) ? Math.min(effectiveRowHeight, 22) : Math.max(effectiveRowHeight, activityLanesExtraHeight(activityLaneCounts.get(task.id) ?? 0));
       heights.push(height);
       top += height;
     }
     return { tops, heights, totalHeight: top };
-  }, [normalizedTasks, visibleTasks, effectiveRowHeight]);
+  }, [normalizedTasks, visibleTasks, effectiveRowHeight, activityLaneCounts]);
   const compositeParentsById = useMemo13(
     () => new Map(normalizedTasks.filter((task) => task.composite).map((task) => [task.id, task])),
     [normalizedTasks]
@@ -14753,16 +15751,6 @@ function TaskGanttChartInner(props, ref) {
     }
     return `calc(${containerHeight} - ${timelineHeaderHeight}px)`;
   }, [containerHeight, isPlanFactMode, isTableMatrixMode, timelineHeaderHeight]);
-  const monthStart = useMemo13(() => {
-    if (dateRange.length === 0) {
-      return new Date(Date.UTC((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth(), 1));
-    }
-    const firstDay = dateRange[0];
-    if (explicitDateRange && !isPlanFactMode) {
-      return new Date(firstDay);
-    }
-    return new Date(Date.UTC(firstDay.getUTCFullYear(), firstDay.getUTCMonth(), 1));
-  }, [dateRange, explicitDateRange, isPlanFactMode]);
   const todayIndex = useMemo13(() => {
     const today = getTodayLocalUtcDate();
     return dateRange.findIndex((day) => day.getTime() === today.getTime());
@@ -14805,12 +15793,23 @@ function TaskGanttChartInner(props, ref) {
       const nextScrollTop = container.scrollTop;
       const nextScrollLeft = container.scrollLeft;
       const nextChartScrollLeft = Math.max(0, nextScrollLeft);
+      const bucketedScrollTop = Math.floor(nextScrollTop / SCROLL_TOP_BUCKET_PX) * SCROLL_TOP_BUCKET_PX;
+      const bucketedChartScrollLeft = Math.floor(nextChartScrollLeft / HORIZONTAL_WINDOW_BUCKET_PX) * HORIZONTAL_WINDOW_BUCKET_PX;
       setTaskListHasRightShadow(
         (previous) => previous === nextHasRightShadow ? previous : nextHasRightShadow
       );
-      setScrollViewport(
-        (previous) => previous.viewportHeight > 0 && nextViewportHeight === 0 ? { scrollTop: nextScrollTop, viewportHeight: previous.viewportHeight } : previous.scrollTop === nextScrollTop && previous.viewportHeight === nextViewportHeight ? previous : { scrollTop: nextScrollTop, viewportHeight: nextViewportHeight }
-      );
+      setScrollViewport((previous) => {
+        const resolvedViewportHeight = previous.viewportHeight > 0 && nextViewportHeight === 0 ? previous.viewportHeight : nextViewportHeight;
+        if (previous.scrollTop === bucketedScrollTop && previous.viewportHeight === resolvedViewportHeight && previous.viewportWidth === nextViewportWidth && previous.chartScrollLeft === bucketedChartScrollLeft) {
+          return previous;
+        }
+        return {
+          scrollTop: bucketedScrollTop,
+          viewportHeight: resolvedViewportHeight,
+          viewportWidth: nextViewportWidth,
+          chartScrollLeft: bucketedChartScrollLeft
+        };
+      });
       setPlanFactDateWindow((previous) => {
         if (!isPlanFactMode || dateRange.length === 0 || nextViewportWidth <= 0) {
           return previous;
@@ -14926,11 +15925,15 @@ function TaskGanttChartInner(props, ref) {
       return;
     }
     previewPositionStore.clear();
+    activityPreviewStore.clear();
+    activityBlockStore.clear();
+    activityDragOwner.set(null);
+    activityActivationStore.setActiveKey(null);
     setCascadeOverrides((current) => current.size === 0 ? current : /* @__PURE__ */ new Map());
     setPreviewTasksById((current) => current.size === 0 ? current : /* @__PURE__ */ new Map());
     setDraggedTaskOverride((current) => current === null ? current : null);
     setDragGuideLines((current) => current === null ? current : null);
-  }, [controlledScheduleIdentity, previewPositionStore]);
+  }, [controlledScheduleIdentity, previewPositionStore, activityPreviewStore, activityBlockStore, activityDragOwner, activityActivationStore]);
   useEffect11(() => {
     const result = validateDependencies(tasks);
     setValidationResult(result);
@@ -14941,7 +15944,11 @@ function TaskGanttChartInner(props, ref) {
       window.clearTimeout(clearSelectedTaskTimeoutRef.current);
     }
     previewPositionStore.clear();
-  }, [previewPositionStore]);
+    activityPreviewStore.clear();
+    activityBlockStore.clear();
+    activityDragOwner.set(null);
+    activityActivationStore.setActiveKey(null);
+  }, [previewPositionStore, activityPreviewStore, activityBlockStore, activityDragOwner, activityActivationStore]);
   const handleTaskChange = useCallback10((updatedTasks, durationEdit) => {
     let updatedTask = updatedTasks[0];
     if (!updatedTask) return;
@@ -14987,9 +15994,9 @@ function TaskGanttChartInner(props, ref) {
       return;
     }
     if (datesChanged && isTaskParent(updatedTask.id, tasks)) {
-      const projectDayDelta = (from, to) => businessDays && isCustomWeekend ? getBusinessDayOffset(from, to, isCustomWeekend) : Math.round((to.getTime() - from.getTime()) / DAY_MS);
-      const deltaStart = projectDayDelta(origStart, newStart);
-      const deltaEnd = projectDayDelta(origEnd, newEnd);
+      const projectDayDelta2 = (from, to) => businessDays && isCustomWeekend ? getBusinessDayOffset(from, to, isCustomWeekend) : Math.round((to.getTime() - from.getTime()) / DAY_MS);
+      const deltaStart = projectDayDelta2(origStart, newStart);
+      const deltaEnd = projectDayDelta2(origEnd, newEnd);
       const isUniformMove = deltaStart === deltaEnd && deltaStart !== 0;
       if (!isUniformMove) {
         const anchor = deltaStart === 0 ? "start" : deltaEnd === 0 ? "end" : "start";
@@ -15177,6 +16184,15 @@ function TaskGanttChartInner(props, ref) {
     }
     return ids;
   }, [draggedTaskOverride]);
+  const horizontalWindow = useMemo13(() => {
+    const width = scrollViewport.viewportWidth;
+    if (width <= 0) return void 0;
+    const left = scrollViewport.chartScrollLeft;
+    return {
+      startPx: Math.max(0, left - HORIZONTAL_WINDOW_OVERSCAN_PX),
+      endPx: left + width + HORIZONTAL_WINDOW_OVERSCAN_PX
+    };
+  }, [scrollViewport.chartScrollLeft, scrollViewport.viewportWidth]);
   const visibleTaskWindowIndices = useMemo13(() => {
     const totalTasks = visibleTasks.length;
     if (totalTasks === 0) {
@@ -15511,6 +16527,9 @@ function TaskGanttChartInner(props, ref) {
   const handlePanStart = useCallback10((e) => {
     if (e.button !== 0) return;
     const target = e.target;
+    if (!target.closest(".gantt-tr-activityBar")) {
+      activityActivationStore.setActiveKey(null);
+    }
     if (target.closest("[data-taskbar]")) return;
     if (target.closest("input, button, textarea, [contenteditable]")) return;
     if (target.closest(".gantt-tl-overlay")) return;
@@ -15531,7 +16550,7 @@ function TaskGanttChartInner(props, ref) {
     }
     container.style.cursor = "grabbing";
     e.preventDefault();
-  }, []);
+  }, [activityActivationStore]);
   useEffect11(() => {
     const flushPanMove = () => {
       const pan = panStateRef.current;
@@ -15761,7 +16780,8 @@ function TaskGanttChartInner(props, ref) {
                                 dayWidth,
                                 totalHeight: totalGridHeight,
                                 viewMode,
-                                isCustomWeekend
+                                isCustomWeekend,
+                                horizontalWindow
                               }
                             ),
                             todayInRange && /* @__PURE__ */ jsx21(
@@ -15802,6 +16822,7 @@ function TaskGanttChartInner(props, ref) {
                                 selectedDep: selectedChip,
                                 businessDays,
                                 weekendPredicate: isCustomWeekend,
+                                horizontalWindow,
                                 onDependencyClick: handleDependencyLineClick,
                                 criticalTaskIds: criticalPathMode ? criticalTaskIds : void 0
                               }
@@ -15908,6 +16929,7 @@ function TaskGanttChartInner(props, ref) {
                                         setDragGuideLines((current) => current === null ? current : null);
                                         setDraggedTaskOverride((current) => current === null ? current : null);
                                         previewPositionStore.clear();
+                                        activityPreviewStore.clear();
                                         setCascadeOverrides((current) => current.size === 0 ? current : /* @__PURE__ */ new Map());
                                         setPreviewTasksById((current) => current.size === 0 ? current : /* @__PURE__ */ new Map());
                                       }
@@ -15918,6 +16940,16 @@ function TaskGanttChartInner(props, ref) {
                                     disableConstraints: disableConstraints ?? false,
                                     deferCascadePreview: normalizedTasks.length >= 1e3,
                                     previewPositionStore,
+                                    activityPreviewStore,
+                                    activityBlockStore,
+                                    activityDragOwner,
+                                    activityActivationStore,
+                                    activityClickToDrag,
+                                    activityActivationMode,
+                                    showActivityLinks,
+                                    showActivityLag,
+                                    activityTooltip,
+                                    horizontalWindow,
                                     onCascadeProgress: handleCascadeProgress,
                                     onCascade: handleCascade,
                                     onScheduleIntent,
@@ -16024,6 +17056,9 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   return target.includes(search);
 };
 export {
+  ACTIVITY_LANES_PADDING,
+  ACTIVITY_LANE_BAR_HEIGHT,
+  ACTIVITY_LANE_STEP,
   Button,
   Calendar,
   DAY_MS,
@@ -16045,6 +17080,11 @@ export {
   TaskRow_default as TaskRow,
   TimeScaleHeader_default as TimeScaleHeader,
   TodayIndicator_default as TodayIndicator,
+  activityBounds,
+  activityChainMinStartDelta,
+  activityLanesExtraHeight,
+  activitySpanMs,
+  activityStartConstraint,
   addBusinessDays2 as addBusinessDays,
   alignToWorkingDay,
   and,
@@ -16067,6 +17107,7 @@ export {
   cascadeByLinks,
   clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS,
+  computeActivityLanes,
   computeCriticalPath,
   computeLagFromDates,
   computeParentDates,
@@ -16121,10 +17162,12 @@ export {
   normalizeUTCDate,
   not,
   or,
+  packIntervals,
   parseDateOnly,
   parseUTCDate,
   pixelsToDate,
   progressInRange,
+  pushActivityChain,
   recalculateIncomingLags,
   recalculateProjectSchedule,
   recalculateTaskFromDependencies,
@@ -16134,6 +17177,8 @@ export {
   resolveDateRangeFromPixels,
   resolveTaskHorizontalGeometry,
   scaleTaskSubtreeDuration,
+  shiftActivityChain,
+  shiftActivityDate,
   shiftBusinessDayOffset,
   subtractBusinessDays2 as subtractBusinessDays,
   universalCascade,