gantt-lib 0.136.0 → 0.137.0

package/dist/index.js

@@ -33,6 +33,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ACTIVITY_LANES_PADDING: () => ACTIVITY_LANES_PADDING,
+  ACTIVITY_LANE_BAR_HEIGHT: () => ACTIVITY_LANE_BAR_HEIGHT,
+  ACTIVITY_LANE_STEP: () => ACTIVITY_LANE_STEP,
   Button: () => Button,
   Calendar: () => Calendar,
   DAY_MS: () => DAY_MS,
@@ -54,6 +57,10 @@ __export(index_exports, {
   TaskRow: () => TaskRow_default,
   TimeScaleHeader: () => TimeScaleHeader_default,
   TodayIndicator: () => TodayIndicator_default,
+  activityChainMinStartDelta: () => activityChainMinStartDelta,
+  activityLanesExtraHeight: () => activityLanesExtraHeight,
+  activitySpanMs: () => activitySpanMs,
+  activityStartConstraint: () => activityStartConstraint,
   addBusinessDays: () => addBusinessDays2,
   alignToWorkingDay: () => alignToWorkingDay,
   and: () => and,
@@ -76,6 +83,7 @@ __export(index_exports, {
   cascadeByLinks: () => cascadeByLinks,
   clampDateRangeForIncomingFS: () => clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS: () => clampTaskRangeForIncomingFS,
+  computeActivityLanes: () => computeActivityLanes,
   computeCriticalPath: () => computeCriticalPath,
   computeLagFromDates: () => computeLagFromDates,
   computeParentDates: () => computeParentDates,
@@ -130,10 +138,12 @@ __export(index_exports, {
   normalizeUTCDate: () => normalizeUTCDate,
   not: () => not,
   or: () => or,
+  packIntervals: () => packIntervals,
   parseDateOnly: () => parseDateOnly,
   parseUTCDate: () => parseUTCDate,
   pixelsToDate: () => pixelsToDate,
   progressInRange: () => progressInRange,
+  pushActivityChain: () => pushActivityChain,
   recalculateIncomingLags: () => recalculateIncomingLags,
   recalculateProjectSchedule: () => recalculateProjectSchedule,
   recalculateTaskFromDependencies: () => recalculateTaskFromDependencies,
@@ -143,6 +153,8 @@ __export(index_exports, {
   resolveDateRangeFromPixels: () => resolveDateRangeFromPixels,
   resolveTaskHorizontalGeometry: () => resolveTaskHorizontalGeometry,
   scaleTaskSubtreeDuration: () => scaleTaskSubtreeDuration,
+  shiftActivityChain: () => shiftActivityChain,
+  shiftActivityDate: () => shiftActivityDate,
   shiftBusinessDayOffset: () => shiftBusinessDayOffset,
   subtractBusinessDays: () => subtractBusinessDays2,
   universalCascade: () => universalCascade,
@@ -611,644 +623,965 @@ 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,
+      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, lane, left, width }) => ({ id, name, color, lag, 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 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];
+    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;
+  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 result;
+}
+
+// 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 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_MS7 = 24 * 60 * 60 * 1e3;
+  return {
+    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS7),
+    end: normalizedEnd
+  };
+}
+function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays = false, weekendPredicate, snapDirection = 1) {
+  return buildTaskRangeFromStart(
+    proposedStart,
+    getTaskDuration(originalStart, originalEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate,
+    snapDirection
+  );
+}
+function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate, taskById) {
+  if (!task.dependencies?.length) {
+    return { start: proposedStart, end: proposedEnd };
+  }
+  let minAllowedStart = null;
+  for (const dep of task.dependencies) {
+    if (dep.type !== "FS") {
+      continue;
+    }
+    const predecessor = 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 (!minAllowedStart || proposedStart.getTime() >= minAllowedStart.getTime()) {
+    return { start: proposedStart, end: proposedEnd };
+  }
+  return buildTaskRangeFromStart(
+    minAllowedStart,
+    getTaskDuration(proposedStart, proposedEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate
+  );
+}
+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);
+  }
+  return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
+}
+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 { childrenByParentId, dependentsByPredecessorId, taskById };
+}
+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);
         }
-        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]
-          }));
-        }
+  }
+  return chain;
+}
+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);
       }
     }
     const dependents = dependentsByPredecessorId.get(currentId) ?? [];
     for (const { task, dependencyIndex } of dependents) {
-      if (task.locked || !task.dependencies) continue;
-      if (childShifted.has(task.id)) continue;
+      if (visited.has(task.id) || !task.dependencies || task.locked) continue;
       const dep = task.dependencies[dependencyIndex];
       if (!dep) continue;
-      const origStart = new Date(task.startDate);
-      const origEnd = new Date(task.endDate);
+      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: currStart,
-          endDate: currEnd,
-          type: currentOriginal.type
+          startDate: predStart,
+          endDate: predEnd,
+          type: currentTask.type
         },
         parseCascadeDateInput
       );
@@ -1257,8 +1590,172 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
         normalizedPredEnd,
         dep.type,
         getDependencyLag(dep),
-        businessDays,
-        weekendPredicate,
+        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,
+        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];
+  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);
+      }
+    }
+    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);
+      }
+    }
+  }
+  return chain;
+}
+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 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;
@@ -1324,13 +1821,13 @@ function computeParentProgress(parentId, tasks) {
   if (children.length === 0) {
     return 0;
   }
-  const DAY_MS6 = 24 * 60 * 60 * 1e3;
+  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_MS6) / DAY_MS6;
+    const duration = (end - start + DAY_MS7) / DAY_MS7;
     const progress = child.progress ?? 0;
     totalWeight += duration;
     weightedSum += duration * progress;
@@ -3047,7 +3544,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;
@@ -3061,7 +3558,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);
     }
@@ -3277,301 +3774,36 @@ var TimeScaleHeader = ({
                   "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__ */ (0, import_jsx_runtime.jsx)("span", { className: "gantt-tsh-dayLabel", children: (0, import_date_fns.format)(day, "d") })
-                  },
-                  `day-${index}`
-                );
-              })
-            )
-          }
-        )
-      ]
-    }
-  );
-};
-var TimeScaleHeader_default = TimeScaleHeader;
-
-// src/components/TaskRow/TaskRow.tsx
-var import_react3 = __toESM(require("react"));
-var import_react_dom = require("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 });
+                    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__ */ (0, import_jsx_runtime.jsx)("span", { className: "gantt-tsh-dayLabel", children: (0, import_date_fns.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
+var import_react3 = __toESM(require("react"));
+var import_react_dom = require("react-dom");
 
 // src/utils/expired.ts
 var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
@@ -4412,18 +4644,243 @@ 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
 var import_jsx_runtime2 = require("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;
+  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 = import_react3.default.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, 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] = (0, import_react3.useState)(false);
     const [compositePreviewPosition, setCompositePreviewPosition] = (0, import_react3.useState)(null);
@@ -4594,35 +5051,380 @@ var TaskRow = import_react3.default.memo(
       const centerX = Math.round(displayLeft + dayWidth / 2);
       const halfSize = Math.round(milestoneGeometry.size / 2);
       return {
-        centerX,
-        left: centerX - halfSize,
-        right: centerX + halfSize,
-        size: milestoneGeometry.size
+        centerX,
+        left: centerX - halfSize,
+        right: centerX + halfSize,
+        size: milestoneGeometry.size
+      };
+    }, [displayLeft, dayWidth, milestoneGeometry.size]);
+    const visualLeft = milestone ? displayMilestoneGeometry.left : displayLeft;
+    const visualWidth = milestone ? displayMilestoneGeometry.size : displayWidth;
+    const compositeSegments = (0, import_react3.useMemo)(() => {
+      if (!task.composite || width <= 0) return [];
+      const laneEnds = [];
+      const segments2 = compositeChildren.map((child) => {
+        const segment = calculateTaskBar(parseUTCDate(child.startDate), parseUTCDate(child.endDate), monthStart, dayWidth);
+        let lane = Math.max(0, laneEnds.length - 1);
+        if (laneEnds.length > 0 && segment.left < laneEnds[lane]) {
+          lane = laneEnds.length;
+        }
+        laneEnds[lane] = segment.left + segment.width;
+        return {
+          id: child.id,
+          name: child.name,
+          left: (segment.left - left) / width * 100,
+          width: segment.width / width * 100,
+          lane,
+          pxLeft: segment.left - left,
+          cut: false
+        };
+      });
+      const lastCutByLane = [];
+      for (const segment of [...segments2].sort((a, b) => a.pxLeft - b.pxLeft)) {
+        segment.cut = segment.pxLeft >= 1 && segment.pxLeft - (lastCutByLane[segment.lane] ?? 0) >= COMPOSITE_SEGMENT_CUT_MIN_PX;
+        if (segment.cut) lastCutByLane[segment.lane] = segment.pxLeft;
+      }
+      return segments2;
+    }, [task.composite, compositeChildren, monthStart, dayWidth, left, width, displayLeft]);
+    const compositeLaneCount = Math.max(1, ...compositeSegments.map((segment) => segment.lane + 1));
+    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 = (0, import_react3.useMemo)(
+      () => 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] = (0, import_react3.useState)(null);
+    const [activityTipId, setActivityTipId] = (0, import_react3.useState)(null);
+    const [activityTipPosition, setActivityTipPosition] = (0, import_react3.useState)(null);
+    const activityTipAnchor = (0, import_react3.useRef)(null);
+    const activityDragStart = (0, import_react3.useRef)(null);
+    const activityConstraintRef = (0, import_react3.useRef)(null);
+    const [activityBlockedBy, setActivityBlockedBy] = (0, import_react3.useState)(null);
+    const visibleActivitySegments = (0, import_react3.useMemo)(() => {
+      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 = (0, import_react3.useCallback)(
+      (listener) => activityPreviewStore?.subscribeTask(task.id, listener) ?? (() => {
+      }),
+      [activityPreviewStore, task.id]
+    );
+    const getActivityOverridesSnapshot = (0, import_react3.useCallback)(
+      () => activityPreviewStore?.getTaskOverrides(task.id),
+      [activityPreviewStore, task.id]
+    );
+    const activityOverrides = (0, import_react3.useSyncExternalStore)(
+      subscribeActivityOverrides,
+      getActivityOverridesSnapshot,
+      () => void 0
+    );
+    const subscribeActivityBlock = (0, import_react3.useCallback)(
+      (listener) => activityBlockStore?.subscribeTask(task.id, listener) ?? (() => {
+      }),
+      [activityBlockStore, task.id]
+    );
+    const getActivityBlockSnapshot = (0, import_react3.useCallback)(
+      () => activityBlockStore?.getTaskBlockers(task.id),
+      [activityBlockStore, task.id]
+    );
+    const blockedActivityIds = (0, import_react3.useSyncExternalStore)(
+      subscribeActivityBlock,
+      getActivityBlockSnapshot,
+      () => void 0
+    );
+    const subscribeActivation = (0, import_react3.useCallback)(
+      (listener) => activityActivationStore?.subscribe(listener) ?? (() => {
+      }),
+      [activityActivationStore]
+    );
+    const getActivationSnapshot = (0, import_react3.useCallback)(
+      () => activityActivationStore?.getActiveKey() ?? null,
+      [activityActivationStore]
+    );
+    const activeActivityKey = (0, import_react3.useSyncExternalStore)(
+      subscribeActivation,
+      getActivationSnapshot,
+      () => null
+    );
+    const activeWork = (0, import_react3.useMemo)(() => {
+      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 = (0, import_react3.useCallback)((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]);
+    (0, import_react3.useEffect)(() => {
+      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 = (0, import_react3.useMemo)(() => {
+      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 = (0, import_react3.useMemo)(() => {
+      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);
+      }
+      return {
+        floor: task.name,
+        name: activity.name,
+        fields: activity.tooltipFields ?? [],
+        context: {
+          task,
+          activity,
+          startDate,
+          endDate,
+          durationDays: activityDurationDays({ startDate, endDate })
+        }
       };
-    }, [displayLeft, dayWidth, milestoneGeometry.size]);
-    const visualLeft = milestone ? displayMilestoneGeometry.left : displayLeft;
-    const visualWidth = milestone ? displayMilestoneGeometry.size : displayWidth;
-    const compositeSegments = (0, import_react3.useMemo)(() => {
-      if (!task.composite || width <= 0) return [];
-      const laneEnds = [];
-      return compositeChildren.map((child) => {
-        const segment = calculateTaskBar(parseUTCDate(child.startDate), parseUTCDate(child.endDate), monthStart, dayWidth);
-        let lane = laneEnds.findIndex((end) => end <= segment.left);
-        if (lane < 0) lane = laneEnds.length;
-        laneEnds[lane] = segment.left + segment.width;
-        return {
-          id: child.id,
-          name: child.name,
-          left: (segment.left - left) / width * 100,
-          width: segment.width / width * 100,
-          lane
-        };
-      });
-    }, [task.composite, compositeChildren, monthStart, dayWidth, left, width, displayLeft]);
-    const compositeLaneCount = Math.max(1, ...compositeSegments.map((segment) => segment.lane + 1));
-    const showCompositeSegments = task.composite && compositeSegments.length > 0 && visualWidth / compositeSegments.length >= 22;
-    const shouldRenderBaseline = showBaseline && baselineGeometry !== null;
-    const hasPreviewPosition = isDragging || effectiveOverridePosition !== void 0;
+    }, [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);
@@ -4655,7 +5457,7 @@ var TaskRow = import_react3.default.memo(
         children: [
           taskDivider === "top" && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-divider gantt-tr-divider-top" }),
           /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gantt-tr-taskContainer", children: [
-            shouldRenderBaseline && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            shouldRenderBaseline && !renderActivities && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
               "div",
               {
                 className: `gantt-tr-baseline ${isParent ? "gantt-tr-baseline-parent" : ""} ${milestone ? "gantt-tr-baseline-milestone" : ""}`,
@@ -4665,7 +5467,114 @@ var TaskRow = import_react3.default.memo(
                 }
               }
             ),
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+            renderActivities && activityLayout && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gantt-tr-activityLanes", children: [
+              activityLinks.elbows.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { className: "gantt-tr-activityLinksSvg", width: "100%", height: "100%", "aria-hidden": "true", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("marker", { id: "arrowhead", markerWidth: "8", markerHeight: "6", markerUnits: "userSpaceOnUse", refX: "7", refY: "3", orient: "auto", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("polygon", { points: "0 0, 8 3, 0 6", fill: "var(--gantt-dependency-line-color, #666666)" }) }) }),
+                activityLinks.elbows.map((link) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("g", { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { className: "gantt-dependency-path", d: link.d, markerEnd: "url(#arrowhead)" }),
+                  showActivityLag && link.lag !== 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                    "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 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__ */ (0, import_jsx_runtime2.jsxs)(
+                  "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: [
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityName", style: { color: activityTextColor(segment.color) }, children: segment.name }),
+                      activityDragEnabled && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
+                        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleRight" })
+                      ] })
+                    ]
+                  },
+                  segment.id
+                );
+              }),
+              activityLinks.gaps.map((gap) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react3.default.Fragment, { children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                  "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__ */ (0, import_jsx_runtime2.jsxs)(
+                  "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__ */ (0, import_jsx_runtime2.jsxs)(
               "div",
               {
                 "data-taskbar": true,
@@ -4749,19 +5658,33 @@ var TaskRow = import_react3.default.memo(
                     }
                   ),
                   !milestone && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-resizeHandle gantt-tr-resizeHandleLeft" }),
-                  showCompositeSegments && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-compositeSegments", "aria-hidden": "true", children: compositeSegments.map((segment) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                    "span",
-                    {
-                      className: "gantt-tr-compositeSegment",
-                      style: {
-                        left: `${segment.left}%`,
-                        width: `${segment.width}%`,
-                        top: `${segment.lane / compositeLaneCount * 100}%`,
-                        height: `${100 / compositeLaneCount}%`
-                      }
-                    },
-                    segment.id
-                  )) }),
+                  shouldRenderCompositeSegments && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-compositeSegments", "aria-hidden": "true", children: [
+                    compositeSegments.map((segment) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                      "span",
+                      {
+                        className: "gantt-tr-compositeSegment",
+                        style: {
+                          left: `${segment.left}%`,
+                          width: `${segment.width}%`,
+                          top: `${segment.lane / compositeLaneCount * 100}%`,
+                          height: `${100 / compositeLaneCount}%`
+                        }
+                      },
+                      segment.id
+                    )),
+                    compositeSegments.map((segment) => segment.cut ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                      "span",
+                      {
+                        className: "gantt-tr-compositeSegmentCut",
+                        style: {
+                          left: `${segment.left}%`,
+                          top: `${segment.lane / compositeLaneCount * 100}%`,
+                          height: `${100 / compositeLaneCount}%`
+                        }
+                      },
+                      `${segment.id}-cut`
+                    ) : null)
+                  ] }),
                   task.composite && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-compositeHoverChevron", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("svg", { className: `gantt-tr-compositeChevron${compositeExpanded ? " gantt-tr-compositeChevron-open" : ""}`, viewBox: "0 0 20 20", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "m7 4 6 6-6 6", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) }) }),
                   showDurationInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-taskDuration", children: isVisualParent ? getChildCountLabel(childCount) : `${durationDays} \u0434` }),
                   progressWidth > 0 && showProgressInside && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gantt-tr-progressText", children: [
@@ -4807,7 +5730,33 @@ var TaskRow = import_react3.default.memo(
               ),
               document.body
             ),
-            !disableDependencyEditing && onDependencyPortPointerDown && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+            activityTipData && activityTipPosition && typeof document !== "undefined" && (0, import_react_dom.createPortal)(
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+                "div",
+                {
+                  className: `gantt-tr-activityTip${activityTipPosition.below ? " gantt-tr-activityTip-below" : ""}`,
+                  style: { left: `${activityTipPosition.left}px`, top: `${activityTipPosition.top}px` },
+                  role: "tooltip",
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityTipName", children: activityTipData.floor }),
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityTipDot", "aria-hidden": "true", children: "\xB7" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityTipWork", children: activityTipData.name }),
+                    activityTooltip && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-activityTipExtra", children: activityTooltip(activityTipData.context) }),
+                    activityTipData.fields.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gantt-tr-activityTipFields", children: activityTipData.fields.map((field) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gantt-tr-activityTipField", children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityTipFieldLabel", children: field.label }),
+                      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-activityTipFieldValue", children: field.value })
+                    ] }, field.label)) }),
+                    activityBlockedBy && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("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__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
               /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
                 "button",
                 {
@@ -4837,7 +5786,7 @@ var TaskRow = import_react3.default.memo(
                 }
               )
             ] }),
-            showTaskDateLabels && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            showTaskDateLabels && !renderActivities && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
               "div",
               {
                 className: `gantt-tr-leftLabels ${task.locked ? "gantt-tr-leftLabels-locked" : ""}`,
@@ -4847,7 +5796,7 @@ var TaskRow = import_react3.default.memo(
                 children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gantt-tr-dateLabel gantt-tr-dateLabelLeft", children: dateRangeLabel })
               }
             ),
-            task.locked && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            task.locked && !renderActivities && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
               "svg",
               {
                 className: "gantt-tr-lockIcon",
@@ -4868,7 +5817,7 @@ var TaskRow = import_react3.default.memo(
                 children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("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__ */ (0, import_jsx_runtime2.jsx)(
+            !showDurationInside && !milestone && !renderActivities && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
               "span",
               {
                 className: `gantt-tr-externalDuration gantt-tr-durationBeforeBar${compactDetail ? " gantt-tr-compositeDuration" : ""}`,
@@ -4876,7 +5825,7 @@ var TaskRow = import_react3.default.memo(
                 children: isVisualParent ? getChildCountLabel(childCount) : `${durationDays} \u0434`
               }
             ),
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+            !renderActivities && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
               "div",
               {
                 className: "gantt-tr-rightLabels",
@@ -5012,10 +5961,10 @@ var import_react6 = __toESM(require("react"));
 var import_jsx_runtime5 = require("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 = import_react6.default.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 = (0, import_react6.useMemo)(() => {
       if (viewMode !== "week") return [];
       return calculateWeekGridLines(dateRange, dayWidth);
@@ -5032,6 +5981,23 @@ var GridBackground = import_react6.default.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 = (0, import_react6.useMemo)(
+      () => weekendBlocks.filter((block) => inHorizontalWindow(block.left, block.width)),
+      [weekendBlocks, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleWeekGridLines = (0, import_react6.useMemo)(
+      () => weekGridLines.filter((line) => inHorizontalWindow(line.x)),
+      [weekGridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleMonthGridLines = (0, import_react6.useMemo)(
+      () => monthGridLines.filter((line) => inHorizontalWindow(line.x)),
+      [monthGridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
+    const visibleGridLines = (0, import_react6.useMemo)(
+      () => gridLines.filter((line) => inHorizontalWindow(line.x)),
+      [gridLines, horizontalWindow?.startPx, horizontalWindow?.endPx]
+    );
     const gridWidth = (0, import_react6.useMemo)(() => {
       return Math.round(dateRange.length * dayWidth);
     }, [dateRange.length, dayWidth]);
@@ -5044,7 +6010,7 @@ var GridBackground = import_react6.default.memo(
           height: `${totalHeight}px`
         },
         children: [
-          showWeekendBlocks && weekendBlocks.map((block, index) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          showWeekendBlocks && visibleWeekendBlocks.map((block, index) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
             "div",
             {
               className: "gantt-gb-weekendBlock",
@@ -5057,7 +6023,7 @@ var GridBackground = import_react6.default.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__ */ (0, import_jsx_runtime5.jsx)(
                 "div",
@@ -5070,7 +6036,7 @@ var GridBackground = import_react6.default.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__ */ (0, import_jsx_runtime5.jsx)(
                 "div",
@@ -5082,8 +6048,8 @@ var GridBackground = import_react6.default.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__ */ (0, import_jsx_runtime5.jsx)(
                 "div",
@@ -5195,7 +6161,8 @@ var DependencyLines = import_react7.default.memo(({
   criticalTaskIds,
   businessDays = true,
   weekendPredicate,
-  onDependencyClick
+  onDependencyClick,
+  horizontalWindow
 }) => {
   const [hoveredLineId, setHoveredLineId] = (0, import_react7.useState)(null);
   const tasksForPositions = allTasks ?? tasks;
@@ -5359,6 +6326,10 @@ var DependencyLines = import_react7.default.memo(({
     }
     return lines2;
   }, [tasks, allTasks, taskPositions, taskIndices, cycleInfo, collapsedParentIds, criticalTaskIds]);
+  const visibleLines = (0, import_react7.useMemo)(() => {
+    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__ */ (0, import_jsx_runtime7.jsxs)(
     "svg",
@@ -5466,7 +6437,7 @@ var DependencyLines = import_react7.default.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";
@@ -6306,7 +7277,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];
@@ -6335,25 +7306,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
 var import_jsx_runtime14 = require("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__ */ (0, import_jsx_runtime14.jsxs)(
   "svg",
@@ -10459,7 +11430,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,
@@ -12437,7 +13412,7 @@ var import_react17 = require("react");
 var import_jsx_runtime19 = require("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(" ");
 }
@@ -12472,8 +13447,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) {
@@ -12803,7 +13778,7 @@ function TableMatrix({
 // src/components/PlanFactMatrix/PlanFactMatrix.tsx
 var import_react18 = __toESM(require("react"));
 var import_jsx_runtime20 = require("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(" ");
 }
@@ -12833,8 +13808,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;
@@ -14203,80 +15178,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
 var import_jsx_runtime21 = require("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;
@@ -14469,6 +15377,12 @@ function TaskGanttChartInner(props, ref) {
     skeletonStartJitterDays = 0,
     showTaskDateLabels = true,
     showTaskNames = true,
+    showCompositeSegments = true,
+    activityClickToDrag = false,
+    activityActivationMode = "none",
+    showActivityLinks = true,
+    showActivityLag = true,
+    activityTooltip,
     timelineMarkers,
     additionalColumns,
     hiddenTaskListColumns,
@@ -14502,17 +15416,41 @@ function TaskGanttChartInner(props, ref) {
   const clearSelectedTaskTimeoutRef = (0, import_react19.useRef)(null);
   const hasAutoScrolledToTodayRef = (0, import_react19.useRef)(false);
   const previewPositionStoreRef = (0, import_react19.useRef)(null);
+  const activityPreviewStoreRef = (0, import_react19.useRef)(null);
+  const activityBlockStoreRef = (0, import_react19.useRef)(null);
+  const activityDragOwnerRef = (0, import_react19.useRef)(null);
+  const activityActivationStoreRef = (0, import_react19.useRef)(null);
   const renderedTaskIdsRef = (0, import_react19.useRef)(/* @__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] = (0, import_react19.useState)(null);
   const [taskListHasRightShadow, setTaskListHasRightShadow] = (0, import_react19.useState)(false);
   const [internalTaskDateChangeMode, setInternalTaskDateChangeMode] = (0, import_react19.useState)("preserve-duration");
   const [scrollViewport, setScrollViewport] = (0, import_react19.useState)(() => ({
     scrollTop: 0,
-    viewportHeight: getInitialScrollViewportHeight(containerHeight, headerHeight + 1)
+    viewportHeight: getInitialScrollViewportHeight(containerHeight, headerHeight + 1),
+    // Ширина видимой области графика и «бакетированный» горизонтальный скролл —
+    // основа горизонтального окна рендера (см. horizontalWindow).
+    viewportWidth: 0,
+    chartScrollLeft: 0
   }));
   const [forceFullRenderForPrint, setForceFullRenderForPrint] = (0, import_react19.useState)(false);
   const [planFactDateWindow, setPlanFactDateWindow] = (0, import_react19.useState)({ start: 0, end: 0 });
@@ -14690,8 +15628,8 @@ function TaskGanttChartInner(props, ref) {
   const resolvedRowContentLines = isPlanFactMode ? Math.max(2, Math.floor(rowContentLines)) : Math.max(1, Math.floor(rowContentLines));
   const shouldFillParentRowsInTaskList = fillParentRowsInTaskList ?? isPlanFactMode;
   const effectiveRowHeight = (0, import_react19.useMemo)(
-    () => Math.max(rowHeight, 10 + resolvedRowContentLines * 18),
-    [resolvedRowContentLines, rowHeight]
+    () => rowContentLines === 0 && !isPlanFactMode ? rowHeight : Math.max(rowHeight, 10 + resolvedRowContentLines * 18),
+    [isPlanFactMode, resolvedRowContentLines, rowContentLines, rowHeight]
   );
   const normalizedTasks = (0, import_react19.useMemo)(() => {
     const ordered = normalizeHierarchyTasks(tasks);
@@ -14750,14 +15688,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 = (0, import_react19.useMemo)(
     () => {
@@ -14802,6 +15747,25 @@ function TaskGanttChartInner(props, ref) {
     }
     return tasks2;
   }, [normalizedTasks, collapsedParentIds, filterMode, taskFilter, criticalPathMode, criticalTaskIds]);
+  const monthStart = (0, import_react19.useMemo)(() => {
+    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 = (0, import_react19.useMemo)(() => {
+    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 = (0, import_react19.useMemo)(() => {
     const compositeIds = new Set(normalizedTasks.filter((task) => task.composite).map((task) => task.id));
     const tops = [];
@@ -14809,12 +15773,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 = (0, import_react19.useMemo)(
     () => new Map(normalizedTasks.filter((task) => task.composite).map((task) => [task.id, task])),
     [normalizedTasks]
@@ -14853,16 +15817,6 @@ function TaskGanttChartInner(props, ref) {
     }
     return `calc(${containerHeight} - ${timelineHeaderHeight}px)`;
   }, [containerHeight, isPlanFactMode, isTableMatrixMode, timelineHeaderHeight]);
-  const monthStart = (0, import_react19.useMemo)(() => {
-    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 = (0, import_react19.useMemo)(() => {
     const today = getTodayLocalUtcDate();
     return dateRange.findIndex((day) => day.getTime() === today.getTime());
@@ -14905,12 +15859,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;
@@ -15026,11 +15991,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]);
   (0, import_react19.useEffect)(() => {
     const result = validateDependencies(tasks);
     setValidationResult(result);
@@ -15041,7 +16010,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 = (0, import_react19.useCallback)((updatedTasks, durationEdit) => {
     let updatedTask = updatedTasks[0];
     if (!updatedTask) return;
@@ -15277,6 +16250,15 @@ function TaskGanttChartInner(props, ref) {
     }
     return ids;
   }, [draggedTaskOverride]);
+  const horizontalWindow = (0, import_react19.useMemo)(() => {
+    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 = (0, import_react19.useMemo)(() => {
     const totalTasks = visibleTasks.length;
     if (totalTasks === 0) {
@@ -15611,6 +16593,9 @@ function TaskGanttChartInner(props, ref) {
   const handlePanStart = (0, import_react19.useCallback)((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;
@@ -15631,7 +16616,7 @@ function TaskGanttChartInner(props, ref) {
     }
     container.style.cursor = "grabbing";
     e.preventDefault();
-  }, []);
+  }, [activityActivationStore]);
   (0, import_react19.useEffect)(() => {
     const flushPanMove = () => {
       const pan = panStateRef.current;
@@ -15861,7 +16846,8 @@ function TaskGanttChartInner(props, ref) {
                                 dayWidth,
                                 totalHeight: totalGridHeight,
                                 viewMode,
-                                isCustomWeekend
+                                isCustomWeekend,
+                                horizontalWindow
                               }
                             ),
                             todayInRange && /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
@@ -15902,6 +16888,7 @@ function TaskGanttChartInner(props, ref) {
                                 selectedDep: selectedChip,
                                 businessDays,
                                 weekendPredicate: isCustomWeekend,
+                                horizontalWindow,
                                 onDependencyClick: handleDependencyLineClick,
                                 criticalTaskIds: criticalPathMode ? criticalTaskIds : void 0
                               }
@@ -16008,6 +16995,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());
                                       }
@@ -16018,6 +17006,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,
@@ -16035,6 +17033,7 @@ function TaskGanttChartInner(props, ref) {
                                     viewMode,
                                     showTaskDateLabels,
                                     showTaskNames,
+                                    showCompositeSegments,
                                     onCompositeToggle: task.composite ? (source) => handleCompositeBarToggle(task.id, source) : void 0,
                                     compositeExpanded: task.composite ? !collapsedParentIds.has(task.id) : void 0
                                   }
@@ -16124,6 +17123,9 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACTIVITY_LANES_PADDING,
+  ACTIVITY_LANE_BAR_HEIGHT,
+  ACTIVITY_LANE_STEP,
   Button,
   Calendar,
   DAY_MS,
@@ -16145,6 +17147,10 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   TaskRow,
   TimeScaleHeader,
   TodayIndicator,
+  activityChainMinStartDelta,
+  activityLanesExtraHeight,
+  activitySpanMs,
+  activityStartConstraint,
   addBusinessDays,
   alignToWorkingDay,
   and,
@@ -16167,6 +17173,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   cascadeByLinks,
   clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS,
+  computeActivityLanes,
   computeCriticalPath,
   computeLagFromDates,
   computeParentDates,
@@ -16221,10 +17228,12 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   normalizeUTCDate,
   not,
   or,
+  packIntervals,
   parseDateOnly,
   parseUTCDate,
   pixelsToDate,
   progressInRange,
+  pushActivityChain,
   recalculateIncomingLags,
   recalculateProjectSchedule,
   recalculateTaskFromDependencies,
@@ -16234,6 +17243,8 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   resolveDateRangeFromPixels,
   resolveTaskHorizontalGeometry,
   scaleTaskSubtreeDuration,
+  shiftActivityChain,
+  shiftActivityDate,
   shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,