@outbuild-company/schedule-core 1.1.1 → 1.2.0

package/dist/index.cjs

@@ -835,49 +835,63 @@ function appendToBucket(index, key, link) {
   }
   index.set(key, [link]);
 }
-function filterToChainEndpoints(leaves, adapter, linksByActivity) {
+function filterToChainEndpoints(leaves, adapter, linksByActivity, selectSourceLinks) {
   if (leaves.length <= 1) return leaves;
   const leafSet = new Set(leaves.map(String));
   const keptLeaves = [];
   for (const leafId of leaves) {
-    if (!shouldSkipMidChainLeaf(leafId, leafSet, adapter, linksByActivity)) {
+    if (!shouldSkipMidChainLeaf(
+      leafId,
+      leafSet,
+      adapter,
+      linksByActivity,
+      selectSourceLinks
+    )) {
       keptLeaves.push(leafId);
     }
   }
   return keptLeaves.length > 0 ? keptLeaves : leaves;
 }
-function shouldSkipMidChainLeaf(leafId, leafSet, adapter, linksByActivity) {
+function shouldSkipMidChainLeaf(leafId, leafSet, adapter, linksByActivity, selectSourceLinks) {
   const leafKey = String(leafId);
   const leafTask = adapter.getActivity(leafId);
   if (!leafTask) return false;
   if (leafTask.autoScheduling === false) return false;
   const linksOnThis = linksByActivity.get(leafKey) ?? [];
   for (const siblingLink of linksOnThis) {
-    if (isSelfLink(siblingLink)) continue;
-    const otherId = otherEndOf(siblingLink, leafKey);
-    if (!leafSet.has(String(otherId))) continue;
-    const siblingTask = adapter.getActivity(otherId);
-    if (!siblingTask) continue;
-    if (siblingTask.autoScheduling === false) continue;
-    if (linkConnectsMidChain(siblingLink, leafId, leafTask, otherId, siblingTask)) {
+    if (isMidChainConnection(
+      siblingLink,
+      leafKey,
+      leafTask,
+      leafSet,
+      adapter,
+      selectSourceLinks
+    ))
       return true;
-    }
   }
   return false;
 }
+function isMidChainConnection(link, leafKey, leafTask, leafSet, adapter, selectSourceLinks) {
+  if (isSelfLink(link)) return false;
+  const relevantDirection = selectSourceLinks ? String(link.source) === leafKey : String(link.target) === leafKey;
+  if (!relevantDirection) return false;
+  const otherId = otherEndOf(link, leafKey);
+  if (!leafSet.has(String(otherId))) return false;
+  const siblingTask = adapter.getActivity(otherId);
+  return Boolean(
+    siblingTask?.autoScheduling !== false && siblingTask && linkConnectsMidChain(link, leafTask, siblingTask)
+  );
+}
 function isSelfLink(link) {
   return link.source === link.target;
 }
 function otherEndOf(link, knownEndKey) {
   return String(link.source) === knownEndKey ? link.target : link.source;
 }
-function linkConnectsMidChain(link, leafId, leafTask, otherId, siblingTask) {
+function linkConnectsMidChain(link, leafTask, siblingTask) {
   const lag = link.lag ?? 0;
   const absLag = Math.abs(lag);
-  if (link.target === leafId && absLag <= leafTask.durationHours) return true;
-  if (link.target === otherId && absLag <= siblingTask.durationHours)
-    return true;
-  return false;
+  return String(link.target) === String(siblingTask.id) && absLag <= siblingTask.durationHours || String(link.target) === String(leafTask.id) && absLag <= leafTask.durationHours;
 }
 function expandParentLinks(links, adapter) {
   const expanded = [];
@@ -886,116 +900,172 @@ function expandParentLinks(links, adapter) {
   for (const link of links) {
     const sourceIsSummary = isSummary2(link.source, adapter);
     const targetIsSummary = isSummary2(link.target, adapter);
-    if (sourceIsSummary && targetIsSummary) continue;
-    if (targetIsSummary && isDescendantOf(link.source, link.target, adapter) || sourceIsSummary && isDescendantOf(link.target, link.source, adapter)) {
+    if (isInternalSummaryLink(link, sourceIsSummary, targetIsSummary, adapter))
       continue;
-    }
     if (!sourceIsSummary && !targetIsSummary) {
       expanded.push(link);
       continue;
     }
-    let sourceIds = sourceIsSummary ? getLeafDescendants(link.source, adapter) : [link.source];
-    let targetIds = targetIsSummary ? getLeafDescendants(link.target, adapter) : [link.target];
-    if (sourceIsSummary) {
-      sourceIds = keepBoundDefiningLeaves(sourceIds, false, adapter);
-    }
-    if (targetIsSummary) {
-      const chainEndpoints = filterToChainEndpoints(
-        targetIds,
-        adapter,
-        linksByActivity
-      );
-      if (link.type === LINK_TYPE.FINISH_TO_FINISH || link.type === LINK_TYPE.START_TO_FINISH) {
-        virtualIdCounter = pushOffsetPreservingLinks(
-          expanded,
-          sourceIds,
-          chainEndpoints,
-          link,
-          link.target,
-          adapter,
-          virtualIdCounter
-        );
-        continue;
-      }
-      targetIds = keepBoundDefiningLeaves(chainEndpoints, true, adapter);
-    }
-    virtualIdCounter = pushExpandedLinks(
+    const sourceIds = expandedEndpoints(
+      link.source,
+      sourceIsSummary,
+      adapter,
+      linksByActivity,
+      true
+    );
+    const targetIds = expandedEndpoints(
+      link.target,
+      targetIsSummary,
+      adapter,
+      linksByActivity,
+      false
+    );
+    virtualIdCounter = pushOffsetPreservingLinks(
       expanded,
       sourceIds,
       targetIds,
       link,
-      virtualIdCounter
+      adapter,
+      virtualIdCounter,
+      linksByActivity
     );
   }
   return expanded;
 }
-function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, summaryId, adapter, virtualIdCounter) {
-  const summary = adapter.getActivity(summaryId);
-  const summaryStart = summary?.startDate;
-  const summaryDuration = summary?.durationHours ?? 0;
-  const userLag = originalLink.lag ?? 0;
-  const source = adapter.getActivity(originalLink.source);
-  let counter = virtualIdCounter;
-  for (const srcId of sourceIds) {
-    for (const tgtId of leafIds) {
-      if (String(srcId) === String(tgtId)) continue;
-      const leaf = adapter.getActivity(tgtId);
-      const offTarget = summaryStart && leaf && source ? adapter.calculateDuration({
-        startDate: summaryStart,
-        endDate: leaf.startDate,
-        task: source
-      }) : 0;
-      expanded.push({
-        id: `virtual_${originalLink.id}_${counter}`,
-        source: srcId,
-        target: tgtId,
-        type: originalLink.type,
-        lag: originalLink.lag,
-        _sourceLag: 0,
-        _targetLag: -summaryDuration,
-        _trueLag: userLag + offTarget
-      });
-      counter += 1;
-    }
-  }
-  return counter;
+function isInternalSummaryLink(link, sourceIsSummary, targetIsSummary, adapter) {
+  return targetIsSummary && isDescendantOf(link.source, link.target, adapter) || sourceIsSummary && isDescendantOf(link.target, link.source, adapter);
 }
-function keepBoundDefiningLeaves(leaves, startBound, adapter) {
-  if (leaves.length <= 1) return leaves;
-  let best = null;
-  for (const id of leaves) {
-    const a = adapter.getActivity(id);
-    const d = startBound ? a?.startDate : a?.endDate;
-    if (!d) continue;
-    const t = d.getTime();
-    if (best === null) best = t;
-    else if (startBound ? t < best : t > best) best = t;
-  }
-  if (best === null) return leaves;
-  const kept = leaves.filter((id) => {
-    const a = adapter.getActivity(id);
-    const d = startBound ? a?.startDate : a?.endDate;
-    return d != null && d.getTime() === best;
+function expandedEndpoints(activityId, summary, adapter, linksByActivity, sourceSide) {
+  if (!summary) return [activityId];
+  return filterToChainEndpoints(
+    getLeafDescendants(activityId, adapter),
+    adapter,
+    linksByActivity,
+    sourceSide
+  );
+}
+function deriveSummaryBoundsWithDates(summaryId, adapter, resolveDates) {
+  const leaves = getLeafDescendants(summaryId, adapter);
+  if (leaves.length === 0) return null;
+  let earliestStart = null;
+  let latestEnd = null;
+  for (const leafId of leaves) {
+    const leafDates = resolveDates(leafId);
+    if (!leafDates) continue;
+    const startsEarlier = earliestStart === null || leafDates.startDate < earliestStart;
+    if (startsEarlier) earliestStart = leafDates.startDate;
+    const endsLater = latestEnd === null || leafDates.endDate > latestEnd;
+    if (endsLater) latestEnd = leafDates.endDate;
+  }
+  if (earliestStart === null || latestEnd === null) return null;
+  return { startDate: earliestStart, endDate: latestEnd };
+}
+function deriveSummaryBounds(summaryId, adapter) {
+  return deriveSummaryBoundsWithDates(summaryId, adapter, (leafId) => {
+    const leaf = adapter.getActivity(leafId);
+    if (!leaf) return null;
+    return { startDate: leaf.startDate, endDate: leaf.endDate };
+  });
+}
+function endpointSpanHours(endpoint, bounds, adapter) {
+  if (!endpoint) return 0;
+  if (!bounds) return endpoint.durationHours;
+  return adapter.calculateDuration({
+    startDate: bounds.startDate,
+    endDate: bounds.endDate,
+    task: endpoint
   });
-  return kept.length > 0 ? kept : leaves;
 }
-function pushExpandedLinks(expanded, sourceIds, targetIds, originalLink, virtualIdCounter) {
+function sourceLagForLeaf(leafId, source, sourceBounds, adapter) {
+  if (!source) return 0;
+  const leaf = adapter.getActivity(leafId);
+  if (!sourceBounds || !leaf) return -source.durationHours;
+  return -adapter.calculateDuration({
+    startDate: sourceBounds.startDate,
+    endDate: leaf.endDate,
+    task: source
+  });
+}
+function hasIncomingRawLink(leafId, linksByActivity) {
+  const leafKey = String(leafId);
+  const bucket = linksByActivity.get(leafKey) ?? [];
+  return bucket.some((rawLink) => String(rawLink.target) === leafKey);
+}
+function targetOffsetForLeaf(leafId, targetStart, source, adapter, linksByActivity) {
+  if (hasIncomingRawLink(leafId, linksByActivity)) return 0;
+  const leaf = adapter.getActivity(leafId);
+  if (!targetStart || !leaf || !source) return 0;
+  return adapter.calculateDuration({
+    startDate: targetStart,
+    endDate: leaf.startDate,
+    task: source
+  });
+}
+function resolveExpansionAnchors(originalLink, adapter) {
+  const source = adapter.getActivity(originalLink.source);
+  const target = adapter.getActivity(originalLink.target);
+  const sourceBounds = deriveSummaryBounds(originalLink.source, adapter);
+  const targetBounds = deriveSummaryBounds(originalLink.target, adapter);
+  const sourceEndpointIsStart = originalLink.type === LINK_TYPE.START_TO_START || originalLink.type === LINK_TYPE.START_TO_FINISH;
+  const targetEndpointIsFinish = originalLink.type === LINK_TYPE.FINISH_TO_FINISH || originalLink.type === LINK_TYPE.START_TO_FINISH;
+  return {
+    source,
+    sourceBounds,
+    targetStart: targetBounds?.startDate ?? target?.startDate,
+    userLag: originalLink.lag ?? 0,
+    sourceEndpointIsStart,
+    targetLag: targetEndpointIsFinish ? -endpointSpanHours(target, targetBounds, adapter) : 0,
+    summarySourceId: originalLink.type === LINK_TYPE.START_TO_START && sourceBounds ? originalLink.source : void 0
+  };
+}
+function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, adapter, virtualIdCounter, linksByActivity) {
+  const anchors = resolveExpansionAnchors(originalLink, adapter);
+  const { source, sourceBounds, targetStart, userLag } = anchors;
+  const { sourceEndpointIsStart, targetLag, summarySourceId } = anchors;
   let counter = virtualIdCounter;
   for (const srcId of sourceIds) {
-    for (const tgtId of targetIds) {
+    const sourceLag = sourceEndpointIsStart ? sourceLagForLeaf(srcId, source, sourceBounds, adapter) : 0;
+    for (const tgtId of leafIds) {
       if (String(srcId) === String(tgtId)) continue;
-      expanded.push({
-        id: `virtual_${originalLink.id}_${counter}`,
-        source: srcId,
-        target: tgtId,
-        type: originalLink.type,
-        lag: originalLink.lag
-      });
+      const offTarget = targetOffsetForLeaf(
+        tgtId,
+        targetStart,
+        source,
+        adapter,
+        linksByActivity
+      );
+      expanded.push(
+        buildVirtualLink(
+          originalLink,
+          srcId,
+          tgtId,
+          counter,
+          sourceLag,
+          targetLag,
+          userLag + offTarget,
+          summarySourceId,
+          offTarget !== 0 && targetLag === 0 ? originalLink.target : void 0
+        )
+      );
       counter += 1;
     }
   }
   return counter;
 }
+function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, trueLag, summarySourceId, offsetSummaryTargetId) {
+  return {
+    id: `virtual_${originalLink.id}_${counter}`,
+    source: sourceId,
+    target: targetId,
+    type: originalLink.type,
+    lag: originalLink.lag,
+    _sourceLag: sourceLag,
+    _targetLag: targetLag,
+    _trueLag: trueLag,
+    ...summarySourceId === void 0 ? {} : { _summarySourceId: summarySourceId },
+    ...offsetSummaryTargetId === void 0 ? {} : { _summaryTargetId: offsetSummaryTargetId }
+  };
+}
 
 // src/autoscheduler/utils/expanded-links-cache.ts
 var ExpandedLinksCache = class {
@@ -1125,33 +1195,49 @@ function normalize(predecessor, successor, link) {
       };
   }
 }
-function calculateSuccessorStartFromLink(predecessor, successor, link, adapter) {
-  const { sourceLag, targetLag, trueLag, isFS, isFF } = normalize(
-    predecessor,
-    successor,
+function summaryAnchoredSourceLag(link, predecessor, adapter) {
+  if (link._summarySourceId === void 0) return null;
+  const summarySource = adapter.getActivity(link._summarySourceId);
+  if (!summarySource) return null;
+  const summaryBounds = deriveSummaryBounds(link._summarySourceId, adapter);
+  if (!summaryBounds) return null;
+  return -adapter.calculateDuration({
+    startDate: summaryBounds.startDate,
+    endDate: predecessor.endDate,
+    task: summarySource
+  });
+}
+function noLagSuccessorStart(predecessor, successor, link, adapter, isEndAnchoredType) {
+  const snapsToPast = successor.durationHours === 0 && isEndAnchoredType;
+  return {
+    successorStart: adapter.getClosestWorkTime({
+      date: predecessor.endDate,
+      dir: snapsToPast ? "past" : "future",
+      task: successor
+    }),
     link
-  );
-  const hasLag = sourceLag !== 0 || targetLag !== 0 || trueLag !== 0;
+  };
+}
+function calculateSuccessorStartFromLink(predecessor, successor, link, adapter) {
+  const {
+    sourceLag: frozenSourceLag,
+    targetLag,
+    trueLag,
+    isFS,
+    isFF
+  } = normalize(predecessor, successor, link);
+  const sourceLag = summaryAnchoredSourceLag(link, predecessor, adapter) ?? frozenSourceLag;
+  const totalLag = sourceLag + targetLag + trueLag;
+  const isZeroDurationSuccessor = successor.durationHours === 0;
+  const hasLag = isZeroDurationSuccessor ? totalLag !== 0 : sourceLag !== 0 || targetLag !== 0 || trueLag !== 0;
   if (!hasLag) {
-    const isFForFS = isFS || isFF;
-    if (successor.durationHours === 0 && isFForFS) {
-      return {
-        successorStart: adapter.getClosestWorkTime({
-          date: predecessor.endDate,
-          dir: "past",
-          task: successor
-        }),
-        link
-      };
-    }
-    return {
-      successorStart: adapter.getClosestWorkTime({
-        date: predecessor.endDate,
-        dir: "future",
-        task: successor
-      }),
-      link
-    };
+    return noLagSuccessorStart(
+      predecessor,
+      successor,
+      link,
+      adapter,
+      isFS || isFF
+    );
   }
   const baseTask = isFS ? successor : predecessor;
   let date2 = adapter.getClosestWorkTime({
@@ -1372,10 +1458,12 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
     const incoming = incomingLinks.get(String(activityId)) ?? [];
     let maxStart = null;
     let drivingLinkId = null;
+    let drivingOffsetIsStale = false;
     for (const link of incoming) {
       const predecessorSnap = adapter.getActivity(link.source);
       if (!predecessorSnap) continue;
       const predDates = getActivityDates(link.source);
+      const predecessorMovedThisRun = predDates.startDate.getTime() !== predecessorSnap.startDate.getTime() || predDates.endDate.getTime() !== predecessorSnap.endDate.getTime();
       const effectivePred = {
         ...predecessorSnap,
         startDate: predDates.startDate,
@@ -1405,8 +1493,13 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
       if (!maxStart || result.successorStart > maxStart) {
         maxStart = result.successorStart;
         drivingLinkId = String(link.id);
+        drivingOffsetIsStale = link._summaryTargetId !== void 0 && !predecessorMovedThisRun;
       }
     }
+    const staleOffsetWouldPullBack = maxStart !== null && drivingOffsetIsStale && maxStart < activity.startDate;
+    if (staleOffsetWouldPullBack) {
+      maxStart = new Date(activity.startDate);
+    }
     const existing = plans.get(activityId);
     const plan = existing ? { ...existing } : {
       activityId,
@@ -1574,31 +1667,33 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
         latestEnd = boundary;
       }
     }
+    const incomingForKind = incomingLinks.get(String(activityId)) ?? [];
+    const isFinishMarker = incomingForKind.some(
+      (incomingLink) => incomingLink.type === LINK_TYPE.FINISH_TO_START || incomingLink.type === LINK_TYPE.FINISH_TO_FINISH
+    );
+    const latestEndAtDayStart = new Date(
+      Date.UTC(
+        latestEnd.getUTCFullYear(),
+        latestEnd.getUTCMonth(),
+        latestEnd.getUTCDate()
+      )
+    );
+    const finishMarkerEnd = () => adapter.getClosestWorkTime({
+      date: latestEndAtDayStart,
+      dir: "past",
+      task: activity
+    });
+    const latestEndLandsInsideWorkingDay = adapter.getClosestWorkTime({ date: latestEnd, dir: "future", task: activity }).getTime() === latestEnd.getTime();
     let snappedEnd;
     if (activity.durationHours === 0 && successorAnchor === null) {
-      snappedEnd = adapter.getClosestWorkTime({
+      snappedEnd = isFinishMarker && latestEndLandsInsideWorkingDay ? finishMarkerEnd() : adapter.getClosestWorkTime({
         date: latestEnd,
         dir: "past",
         task: activity
       });
     } else if (activity.durationHours === 0) {
-      const incoming = incomingLinks.get(String(activityId)) ?? [];
-      const isFinishKind = incoming.some(
-        (l) => l.type === LINK_TYPE.FINISH_TO_START || l.type === LINK_TYPE.FINISH_TO_FINISH
-      );
-      if (isFinishKind) {
-        const dayStart = new Date(
-          Date.UTC(
-            latestEnd.getUTCFullYear(),
-            latestEnd.getUTCMonth(),
-            latestEnd.getUTCDate()
-          )
-        );
-        snappedEnd = adapter.getClosestWorkTime({
-          date: dayStart,
-          dir: "past",
-          task: activity
-        });
+      if (isFinishMarker) {
+        snappedEnd = finishMarkerEnd();
       } else {
         snappedEnd = adapter.getClosestWorkTime({
           date: latestEnd,
@@ -1631,10 +1726,16 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
     plan.endDate = snappedEnd;
     plan.drivingLinkId = null;
     plan.kind = "alap";
+    const predecessorFloor = plan.earliestSchedulingStart ?? null;
     plan.earliestSchedulingStart = null;
     plan.earliestSchedulingEnd = null;
-    plan.latestSchedulingStart = snappedStart;
-    plan.latestSchedulingEnd = snappedEnd;
+    const alapTarget = predecessorFloor !== null && predecessorFloor.getTime() > snappedStart.getTime() ? predecessorFloor : snappedStart;
+    plan.latestSchedulingStart = alapTarget;
+    plan.latestSchedulingEnd = alapTarget === snappedStart ? snappedEnd : adapter.calculateEndDate({
+      startDate: alapTarget,
+      durationHours: activity.durationHours,
+      task: activity
+    });
     limitPlanDates(activity, plan, adapter);
     plans.set(activityId, plan);
   }
@@ -2069,18 +2170,9 @@ var AutoScheduler = class {
       }
       const phaseScope = startPhase("schedule.scoping");
       const allIds = this.adapter.getAllIds();
-      let scopedLinks = activeLinks;
-      let scopedIds = allIds;
-      let scopedIdSet = null;
-      if (options.triggerId !== void 0 && options.triggerId !== null) {
-        const group = findConnectedGroupForTrigger(
-          options.triggerId,
-          activeLinks
-        );
-        scopedLinks = group.links;
-        scopedIds = Array.from(group.activityIds);
-        scopedIdSet = new Set(scopedIds);
-      }
+      const scope = resolveScope(options, activeLinks, this.adapter);
+      const scopedLinks = scope.links;
+      const scopedIdSet = scope.idSet;
       endPhase(phaseScope);
       const phaseTopo = startPhase("schedule.topologicalSort");
       const topoResult = resolveTopoResult(
@@ -2177,6 +2269,34 @@ function endPhase(handle) {
   const elapsed = performance.now() - handle.startedAt;
   console.log(`[scheduler] ${handle.name} ${elapsed.toFixed(1)}ms`);
 }
+function resolveScope(options, activeLinks, adapter) {
+  const triggerId = options.triggerId;
+  if (triggerId === void 0 || triggerId === null) {
+    return { idSet: null, links: activeLinks };
+  }
+  const group = findConnectedGroupForTrigger(triggerId, activeLinks);
+  return widenScopeToAlapActivities(group, activeLinks, adapter);
+}
+function widenScopeToAlapActivities(group, allLinks, adapter) {
+  const idSet = new Set(group.activityIds);
+  const widenedAlapKeys = /* @__PURE__ */ new Set();
+  for (const activity of adapter.getAllActivities()) {
+    const activityKey = String(activity.id);
+    const isOutOfComponentAlap = activity.constraintType === CONSTRAINT_TYPE2.ALAP && !idSet.has(activityKey);
+    if (!isOutOfComponentAlap) continue;
+    widenedAlapKeys.add(activityKey);
+    idSet.add(activityKey);
+  }
+  if (widenedAlapKeys.size === 0) {
+    return { idSet, links: group.links };
+  }
+  const links = [...group.links];
+  for (const link of allLinks) {
+    const touchesWidenedAlap = widenedAlapKeys.has(String(link.source)) || widenedAlapKeys.has(String(link.target));
+    if (touchesWidenedAlap) links.push(link);
+  }
+  return { idSet, links };
+}
 function resolveTopoResult(cache, allIds, allLinks, scopedIdSet) {
   const fullTopo = cache.get(allIds, allLinks);
   if (fullTopo.hasCycles) {
@@ -2194,9 +2314,10 @@ function resolveTopoResult(cache, allIds, allLinks, scopedIdSet) {
 }
 
 // src/internal/post-processors/adjust-link-lag-on-task-move.ts
-function adjustLinkLagOnTaskMove(targetId, adapter) {
+function adjustLinkLagOnTaskMove(targetId, adapter, preEditTarget) {
   const target = adapter.getActivity(targetId);
   if (!target) return;
+  const targetForLagMath = preEditTarget ? { ...target, endDate: preEditTarget.endDate } : target;
   const calendarApi = adapter.calendarReader.getCalendar(
     String(target.calendarId)
   );
@@ -2206,9 +2327,11 @@ function adjustLinkLagOnTaskMove(targetId, adapter) {
     const source = adapter.getActivity(link.source);
     if (!source) continue;
     if (source.constraintType === "alap") continue;
+    const isEndAnchoredIntoMilestone = isMilestoneType(target.type) && (link.type === LINK_TYPE.START_TO_FINISH || link.type === LINK_TYPE.FINISH_TO_FINISH);
+    if (isEndAnchoredIntoMilestone) continue;
     const { sourceDate, targetDate } = pickDatesForLinkType(
       source,
-      target,
+      targetForLagMath,
       link.type
     );
     const newLag = dateMath.computeLagBetweenTasks(
@@ -2256,20 +2379,15 @@ function computeLeafRealWork(workHours, progress) {
 // src/propagations/upward/parent-bounds.ts
 async function updateParentBoundsFromChildren(adapter, dirtyIds, recomputeProgress = true, options = {}) {
   const parents = dirtyIds ? findAncestorsOfDirty(adapter, dirtyIds) : findAllParents(adapter);
-  await recomputeParentsCooperatively(parents, adapter, recomputeProgress, {
+  const progressMode = recomputeProgress ? options.progressMode ?? "freeze-when-no-contribution" : "skip";
+  await recomputeParentsCooperatively(parents, adapter, progressMode, {
     recomputeRealWork: options.recomputeRealWork ?? false
   });
 }
-function recomputeParentBoundsSync(adapter, dirtyIds, recomputeProgress = true) {
-  const parents = findAncestorsOfDirty(adapter, dirtyIds);
-  for (const parentId of parents) {
-    recomputeParentFromChildren(parentId, adapter, recomputeProgress);
-  }
-}
 function recomputeSingleParentDisplayBounds(parentId, adapter) {
-  recomputeParentFromChildren(parentId, adapter, false);
+  recomputeParentFromChildren(parentId, adapter, "skip");
 }
-async function recomputeParentsCooperatively(parents, adapter, recomputeProgress = true, options = {
+async function recomputeParentsCooperatively(parents, adapter, progressMode, options = {
   recomputeRealWork: false
 }) {
   const YIELD_EVERY_N_PARENTS = 200;
@@ -2278,7 +2396,7 @@ async function recomputeParentsCooperatively(parents, adapter, recomputeProgress
     recomputeParentFromChildren(
       parentId,
       adapter,
-      recomputeProgress,
+      progressMode,
       options.recomputeRealWork
     );
     processed += 1;
@@ -2328,7 +2446,7 @@ function aggregateChildren(childrenIds, adapter, includeRealWork) {
   }
   return { minStart, maxEnd, realWorkSum, weightedChildren };
 }
-function recomputeParentFromChildren(parentId, adapter, recomputeProgress = true, recomputeRealWork = false) {
+function recomputeParentFromChildren(parentId, adapter, progressMode = "freeze-when-no-contribution", recomputeRealWork = false) {
   const parent = adapter.getActivity(parentId);
   if (!parent) return;
   const childrenIds = adapter.getChildren(parentId);
@@ -2346,11 +2464,12 @@ function recomputeParentFromChildren(parentId, adapter, recomputeProgress = true
   const progressRollup = computeWeightedProgressRollup(
     aggregate.weightedChildren
   );
-  if (recomputeProgress && progressRollup !== null) {
+  const shouldWriteProgress = progressMode !== "skip" && (progressRollup !== null || progressMode === "zero-when-no-contribution");
+  if (shouldWriteProgress) {
     adapter.setActivityField(
       parentId,
       "progress",
-      roundProgressPerLevel(progressRollup)
+      roundProgressPerLevel(progressRollup ?? 0)
     );
   }
   if (recomputeRealWork) {
@@ -2412,7 +2531,7 @@ function runRecordLastStartDate(activityId, adapter) {
   const activity = adapter.getActivity(activityId);
   if (activity) adapter.setLastStartDate(activityId, activity.startDate);
 }
-function runPostProcessorsOnAdapter(activityId, processorNames, adapter) {
+function runPostProcessorsOnAdapter(activityId, processorNames, adapter, preEditActivity) {
   for (const name of processorNames) {
     const fn = name in POST_PROCESSORS ? POST_PROCESSORS[name] : void 0;
     if (!fn) {
@@ -2421,7 +2540,7 @@ function runPostProcessorsOnAdapter(activityId, processorNames, adapter) {
       );
       continue;
     }
-    fn(activityId, adapter);
+    fn(activityId, adapter, preEditActivity ?? null);
   }
 }
 function runNoOp(name) {
@@ -2694,10 +2813,7 @@ var durationPipeline = {
     );
     return {
       ...fieldChanges(extraFields, {
-        // MAIN treats an ALAP duration edit as a resize from Start: Start is
-        // anchored and Finish moves. Running the ALAP pass would instead
-        // preserve Finish and pull Start, which is not the observed UI flow.
-        autoSchedule: activity.constraintType !== "alap",
+        autoSchedule: true,
         postProcessors: [POST_PROCESSOR.RECORD_LAST_START_DATE]
       }),
       ...constraintCheck.violated ? {
@@ -2859,16 +2975,22 @@ function buildCanonicalRealWorkOverlay(activity, progress, hierarchy) {
   realWorkByActivity.set(activity.id, selfRealWork);
   return realWorkByActivity;
 }
+function summariesOverSummariesDeepestFirst(activity, hierarchy) {
+  const subtreeIds = [activity.id, ...hierarchy.getDescendantIds(activity.id)];
+  const hasSummaryChild = (parentId) => hierarchy.getChildProgressInfo(parentId).some((child) => hierarchy.hasChildren(child.id));
+  const depthOf3 = (activityId) => hierarchy.getAncestorIds(activityId).length;
+  return subtreeIds.filter((candidateId) => hasSummaryChild(String(candidateId))).map(String).sort((first, second) => depthOf3(second) - depthOf3(first));
+}
 function buildAncestorRollupCascade(activity, newValue, hierarchy) {
   const overlay = /* @__PURE__ */ new Map();
   overlay.set(activity.id, newValue);
   for (const descendantId of hierarchy.getDescendantIds(activity.id)) {
     overlay.set(descendantId, newValue);
   }
-  const chain = [];
-  for (const ancestorId of hierarchy.getAncestorIds(activity.id)) {
-    chain.push(ancestorId);
-  }
+  const chain = [
+    ...summariesOverSummariesDeepestFirst(activity, hierarchy),
+    ...hierarchy.getAncestorIds(activity.id)
+  ];
   const mutations = [];
   for (const id of chain) {
     const rollup = computeWeightedProgress(id, overlay, hierarchy);
@@ -3265,6 +3387,8 @@ function checkIsWorkingDay(newDate, activity, ctx) {
   return null;
 }
 function detectEndDateConstraintWarning(activity, newEndDate) {
+  const cannotViolateStartPin = effectiveConstraintType(activity) === CONSTRAINT_TYPE2.MSO;
+  if (cannotViolateStartPin) return void 0;
   const projectedDate = pickProjectedDateForConstraint(
     effectiveConstraintType(activity),
     activity.startDate,
@@ -3285,7 +3409,8 @@ function detectEndDateConstraintWarning(activity, newEndDate) {
 function buildEndDateExtraFields(activity, newEndDate, ctx, violatesConstraint = false) {
   const fields = {};
   const isMilestone = isMilestoneType(activity.type);
-  if (isMilestone && !violatesConstraint) {
+  const seedsMilestoneDate = isMilestone && !violatesConstraint && hasDatelessConstraintType(activity);
+  if (seedsMilestoneDate) {
     Object.assign(fields, setConstraintDate(activity.startDate));
   } else if (violatesConstraint || hasDatelessConstraintType(activity)) {
     Object.assign(
@@ -3295,10 +3420,8 @@ function buildEndDateExtraFields(activity, newEndDate, ctx, violatesConstraint =
     );
   }
   const newDuration = calculateNewDuration(activity, newEndDate, ctx);
-  if (!isMilestone) {
-    const flippedType = typeForNewDuration(activity.durationHours, newDuration);
-    if (flippedType) fields.type = flippedType;
-  }
+  const flippedType = typeForNewDuration(activity.durationHours, newDuration);
+  if (flippedType) fields.type = flippedType;
   Object.assign(fields, setDuration(newDuration));
   fields.endDate = newEndDate;
   return fields;
@@ -3715,6 +3838,49 @@ function setLinkFieldDynamic(state, linkId, field, value) {
   state.setLinkFieldDynamic(linkId, field, value);
 }
 
+// src/internal/state/clone-core-activity.ts
+function cloneCoreActivity(activity) {
+  return {
+    ...activity,
+    startDate: new Date(activity.startDate),
+    endDate: new Date(activity.endDate),
+    constraintDate: cloneNullableDate(activity.constraintDate),
+    dateOrigin: cloneNullableDate(activity.dateOrigin),
+    newActivityIds: [...activity.newActivityIds],
+    pendingRequestIds: [...activity.pendingRequestIds],
+    responsableIds: [...activity.responsableIds],
+    tagIds: [...activity.tagIds],
+    baselinePoints: activity.baselinePoints.map((point) => ({
+      ...point,
+      startDate: cloneNullableDate(point.startDate),
+      endDate: cloneNullableDate(point.endDate)
+    })),
+    baselineSnapshot: cloneBaselineSnapshot(activity.baselineSnapshot),
+    criticalPath: cloneCriticalPath(activity.criticalPath)
+  };
+}
+function cloneNullableDate(value) {
+  return value === null ? null : new Date(value);
+}
+function cloneBaselineSnapshot(value) {
+  if (value === null) return null;
+  return {
+    ...value,
+    startDate: cloneNullableDate(value.startDate),
+    endDate: cloneNullableDate(value.endDate)
+  };
+}
+function cloneCriticalPath(value) {
+  if (value === null) return null;
+  return {
+    ...value,
+    earlyStart: cloneNullableDate(value.earlyStart),
+    earlyFinish: cloneNullableDate(value.earlyFinish),
+    lateStart: cloneNullableDate(value.lateStart),
+    lateFinish: cloneNullableDate(value.lateFinish)
+  };
+}
+
 // src/dispatch/shared/snapshots.ts
 function collectTouchedIds(primary, changes) {
   const ids = /* @__PURE__ */ new Set([String(primary)]);
@@ -3732,13 +3898,7 @@ function snapshotActivities(adapter, ids) {
   return out;
 }
 function structuredCloneActivity(activity) {
-  return {
-    ...activity,
-    startDate: new Date(activity.startDate),
-    endDate: new Date(activity.endDate),
-    constraintDate: activity.constraintDate ? new Date(activity.constraintDate) : null,
-    dateOrigin: activity.dateOrigin ? new Date(activity.dateOrigin) : null
-  };
+  return cloneCoreActivity(activity);
 }
 function applyFieldChanges(adapter, activityId, changes) {
   applyCanonicalPatch(adapter, activityId, changes.patch);
@@ -3766,6 +3926,7 @@ function buildActivityChanges(adapter, before, touched) {
     }
     const beforeSnap = before.get(id);
     const diff = diffActivity(beforeSnap, afterSnap);
+    if (beforeSnap && Object.keys(diff).length === 0) continue;
     if (!beforeSnap) {
       out.push({
         id,
@@ -3790,12 +3951,33 @@ function diffActivity(before, after) {
   const afterRec = after;
   const keys = /* @__PURE__ */ new Set([...Object.keys(beforeRec), ...Object.keys(afterRec)]);
   for (const k of keys) {
-    if (!shallowEqual(beforeRec[k], afterRec[k])) {
+    if (Object.hasOwn(beforeRec, k) !== Object.hasOwn(afterRec, k) || !fieldValueEqual(beforeRec[k], afterRec[k])) {
       fields[k] = { before: beforeRec[k], after: afterRec[k] };
     }
   }
   return fields;
 }
+function fieldValueEqual(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  if (left == null || right == null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right)) return false;
+    if (left.length !== right.length) return false;
+    return left.every((value, index) => fieldValueEqual(value, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object") return false;
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every(
+    (key) => Object.hasOwn(rightRecord, key) && fieldValueEqual(leftRecord[key], rightRecord[key])
+  );
+}
 function collectDirtyForInlineEdit(triggerId, touchedIds, scheduledIds) {
   const dirty = /* @__PURE__ */ new Set();
   dirty.add(triggerId);
@@ -3821,21 +4003,6 @@ function foldCorrelativeShifts(adapter, shifts, excludeIds, beforeSnap, touched)
     beforeSnap.set(shift.activityId, beforeImage);
   }
 }
-function shallowEqual(a, b) {
-  if (a === b) return true;
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (a == null || b == null) return false;
-  if (typeof a !== typeof b) return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!shallowEqual(a[i], b[i])) return false;
-    }
-    return true;
-  }
-  return false;
-}
 
 // src/shared/backend-date.ts
 var BACKEND_DATE_FORMAT_REGEX = /^(\d{4})\/(\d{1,2})\/(\d{1,2})\s+(\d{1,2}):(\d{2})$/;
@@ -3919,6 +4086,77 @@ function computeExpectedProgressLive(rootIds, now, state) {
   for (const activityId of rootIds) visit(activityId);
   return changed;
 }
+function applyExpectedProgressLive(state, now) {
+  const rootIds = [];
+  state.forEachActivity((activity, activityId) => {
+    if (activity.parentId === null) rootIds.push(activityId);
+  });
+  computeExpectedProgressLive(rootIds, now, state);
+}
+
+// src/propagations/shared/get-active-baseline.ts
+function getActiveBaseline(activity) {
+  const points = activity?.baselinePoints;
+  if (!Array.isArray(points) || points.length === 0) return null;
+  return points.find((point) => point.isActiveVersion) ?? null;
+}
+
+// src/columns/expected-progress-base/compute.ts
+var isProject2 = (a) => a.type === "project";
+var activeBaselineOf = (a) => getActiveBaseline(a);
+var leafExpected = (a, now, adapter, defaultBaseCalendarId) => {
+  const base = activeBaselineOf(a);
+  if (!base) return 0;
+  const cal = (base.baseCalendarId != null ? adapter.getBaseCalendar(`${base.baseCalendarId}-base`) : null) ?? (defaultBaseCalendarId ? adapter.getBaseCalendar(defaultBaseCalendarId) : null);
+  if (!cal) return 0;
+  if (!base.startDate || !base.endDate) return 0;
+  return expectedProgressFromBaseline(base.startDate, base.endDate, now, cal);
+};
+function computeExpectedProgress(rootIds, now, adapter, defaultBaseCalendarId = null) {
+  const changed = [];
+  const writeIfChanged = (id, value) => {
+    const a = adapter.getActivity(id);
+    if (!a) return;
+    if (a.expectedProgressBaseline !== value) {
+      adapter.setActivityField(id, "expectedProgressBaseline", value);
+      changed.push(id);
+    }
+  };
+  const visit = (id) => {
+    const a = adapter.getActivity(id);
+    if (!a) return 0;
+    if (!isProject2(a)) {
+      const v2 = leafExpected(a, now, adapter, defaultBaseCalendarId);
+      writeIfChanged(id, v2);
+      return v2;
+    }
+    let acc = 0;
+    for (const childId of adapter.getChildrenIds(id)) {
+      const childBase = visit(childId);
+      const child = adapter.getActivity(childId);
+      const weight = typeof child?.ponderator === "number" ? child.ponderator : 0;
+      acc += childBase * weight;
+    }
+    const v = acc / 100;
+    writeIfChanged(id, v);
+    return v;
+  };
+  for (const id of rootIds) visit(id);
+  return changed;
+}
+function runExpectedProgressBase(state, now, defaultBaseCalendarId = null) {
+  const adapter = {
+    getChildrenIds: (parentId) => state.getChildren(String(parentId)).map((childId) => String(childId)),
+    getActivity: (id) => state.getActivity(id),
+    setActivityField: (id, field, value) => setActivityFieldDynamic(state, id, field, value),
+    getBaseCalendar: (engineId) => state.calendarReader.getCalendar(engineId)
+  };
+  const rootIds = [];
+  state.forEachActivity((activity, id) => {
+    if (activity.parentId === null) rootIds.push(id);
+  });
+  return computeExpectedProgress(rootIds, now, adapter, defaultBaseCalendarId);
+}
 
 // src/columns/status/compute.ts
 var roundToTwoDecimals = (value) => Math.round(value * 100) / 100;
@@ -3954,552 +4192,248 @@ function applyStatusPass(state, criteria) {
   return changed;
 }
 
-// src/internal/hierarchy/visual-order.ts
-var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-function getChildrenInVisualOrder(parentId, adapter) {
-  const children = collectChildrenSnapshots(parentId, adapter);
-  children.sort(byCorrelativeIdThenId);
-  return children.map((a) => String(a.id));
-}
-function iterateInVisualOrder(adapter) {
-  const result = [];
-  const visit = (activity) => {
-    result.push(activity);
-    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
-    for (const childId of childIds) {
-      const child = adapter.getActivity(childId);
-      if (child) visit(child);
-    }
+// src/critical-path/legacy/shims/moment.js
+function moment(input) {
+  const d = input instanceof Date ? new Date(input.getTime()) : input && typeof input === "object" && typeof input.valueOf === "function" ? new Date(input.valueOf()) : new Date(input);
+  const accessor = (getUTC, setUTC) => (value) => {
+    if (value === void 0) return d[getUTC]();
+    d[setUTC](value);
+    return api;
   };
-  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
-  for (const rootId of rootIds) {
-    const root = adapter.getActivity(rootId);
-    if (root) visit(root);
-  }
-  return result;
-}
-function findPreviousNonSelectedSibling(taskId, selected, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return null;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  const idx = siblings.findIndex((id) => String(id) === String(taskId));
-  if (idx <= 0) return null;
-  for (let i = idx - 1; i >= 0; i--) {
-    const candidateId = siblings[i];
-    if (candidateId === void 0) continue;
-    if (!setHas(selected, candidateId)) return candidateId;
-  }
-  return null;
-}
-function visualIndexInParent(taskId, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return -1;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  return siblings.findIndex((id) => String(id) === String(taskId));
+  const api = {
+    __isMomentShim: true,
+    clone: () => moment(d),
+    hours: accessor("getUTCHours", "setUTCHours"),
+    minutes: accessor("getUTCMinutes", "setUTCMinutes"),
+    seconds: accessor("getUTCSeconds", "setUTCSeconds"),
+    milliseconds: accessor("getUTCMilliseconds", "setUTCMilliseconds"),
+    valueOf: () => d.getTime(),
+    toDate: () => new Date(d.getTime()),
+    getTime: () => d.getTime()
+  };
+  return api;
 }
-function collectChildrenSnapshots(parentId, adapter) {
-  const key = String(parentId);
-  if (key === "0") {
-    return adapter.getAllActivities().filter((a) => a.parentId === null);
-  }
-  const childIds = adapter.getChildren(parentId);
-  const out = [];
-  for (const id of childIds) {
-    const snap = adapter.getActivity(id);
-    if (snap) out.push(snap);
+moment.isMoment = (x) => Boolean(x) && typeof x === "object" && x.__isMomentShim === true;
+var moment_default = moment;
+
+// src/critical-path/legacy/helpers/isValidDate.js
+function isDate(obj) {
+  if (obj && obj.constructor === Date) {
+    return Boolean(obj.getFullYear && obj.getMonth && obj.getDate);
   }
-  return out;
-}
-function byCorrelativeIdThenId(a, b) {
-  const ac = correlativeIdOf(a);
-  const bc = correlativeIdOf(b);
-  if (ac !== bc) return ac - bc;
-  return String(a.id).localeCompare(String(b.id));
-}
-function correlativeIdOf(activity) {
-  const raw = activity.correlativeId;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
-}
-function parentKeyOf(activity) {
-  const parentId = activity.parentId;
-  if (parentId === null) return "0";
-  return parentId;
+  return false;
 }
-function setHas(set, id) {
-  if (set.has(id)) return true;
-  return set.has(String(id));
+function isValidDate2(obj) {
+  return isDate(obj) && !isNaN(obj.getTime());
 }
 
-// src/internal/hierarchy/recompute-correlative-ids.ts
-function recomputeCorrelativeIds(adapter) {
-  adapter.invalidateVisualOrderIds?.();
-  const roots = [];
-  adapter.forEachActivity((activity) => {
-    if (isRootParent(activity.parentId)) roots.push(activity);
-  });
-  roots.sort(byCorrelativeId);
-  const stack = [];
-  pushInReverseOrder(stack, roots);
-  const shifts = [];
-  let counter = 0;
-  while (stack.length > 0) {
-    const activity = stack.pop();
-    if (activity.correlativeId !== counter) {
-      const before = typeof activity.correlativeId === "number" ? activity.correlativeId : void 0;
-      shifts.push({ activityId: String(activity.id), before });
-      if (before !== void 0)
-        adapter.noteCorrelativeBefore?.(String(activity.id), before);
-      setCorrelativeId(activity, counter);
-    }
-    counter += 1;
-    const children = collectChildrenSnapshots(String(activity.id), adapter);
-    children.sort(byCorrelativeId);
-    pushInReverseOrder(stack, children);
+// src/critical-path/legacy/helpers/addDurationToDate.js
+function addDurationToDate(activityCalendar, date2, duration, activity) {
+  if (!isValidDate2(new Date(date2))) {
+    throw new Error(
+      `Invalid date argument for calculateEndDate method. Date: ${date2}, Activity: ${JSON.stringify(activity)}`
+    );
   }
-  return shifts;
+  const dateToCalculate = date2;
+  return activityCalendar.calculateEndDate({
+    start_date: new Date(dateToCalculate),
+    duration,
+    unit: "hour",
+    task: activity
+  });
 }
-function pushInReverseOrder(stack, activities) {
-  for (let i = activities.length - 1; i >= 0; i -= 1) {
-    stack.push(activities[i]);
+
+// src/critical-path/legacy/helpers/getNextWorkingHour.js
+function getNextWorkingHour(activityParams) {
+  if (!isValidDate2(new Date(activityParams.dateBaseToCalculate))) {
+    throw new Error("Invalid date argument for getClosestWorkTime method");
   }
-}
-function getCorrelativeId(activity) {
-  const raw = activity.correlativeId;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
-}
-var byCorrelativeId = (a, b) => getCorrelativeId(a) - getCorrelativeId(b);
-function setCorrelativeId(activity, value) {
-  activity.correlativeId = value;
+  const { dateBaseToCalculate, activityCalendar, direction, activity } = activityParams;
+  const newDate = activityCalendar.$gantt.getClosestWorkTime({
+    date: new Date(dateBaseToCalculate),
+    dir: direction,
+    unit: "hour",
+    task: activity
+  });
+  return newDate;
 }
 
-// src/propagations/upward/recompute-real-work.ts
-function recomputeCanonicalRealWork(state) {
-  const rootIds = [];
-  const changedIds = [];
-  state.forEachActivity((activity, activityId) => {
-    if (activity.parentId === null) rootIds.push(String(activityId));
-  });
-  const visit = (activityId) => {
-    const activity = state.getActivity(activityId);
-    if (!activity) return 0;
-    const childIds = [...state.getChildren(activityId)];
-    const realWork = childIds.length === 0 ? computeLeafRealWork(activity.workHours, activity.progress) : childIds.reduce(
-      (total, childId) => total + visit(String(childId)),
-      0
-    );
-    state.setActivityField(
-      activityId,
-      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
-      realWork
-    );
-    changedIds.push(activityId);
-    return realWork;
+// src/critical-path/legacy/helpers/filters.js
+var byFirstLevel = (activity) => {
+  if (!activity) return false;
+  return activity["$level"] === 1;
+};
+var filterByParentType = (activity) => activity.type === "project";
+var avoidSubproject = (activity) => activity["$level"] !== 0;
+var byTaskType = (activity) => activity.type === "task";
+var byTaskTypeAndMilestone = (activity) => activity.type === "task" || activity.type === "milestone";
+var filters_default = {
+  byFirstLevel,
+  filterByParentType,
+  avoidSubproject,
+  byTaskType,
+  byTaskTypeAndMilestone
+};
+
+// src/critical-path/legacy/constants/constraints.js
+var CONSTRAINT_TYPES = Object.freeze({
+  MFO: "mfo",
+  MSO: "mso",
+  FNLT: "fnlt",
+  FNET: "fnet",
+  SNET: "snet",
+  SNLT: "snlt",
+  ALAP: "alap",
+  ASAP: "asap"
+});
+
+// src/critical-path/legacy/constants/linkTypes.js
+var LINK_TYPES = Object.freeze({
+  FS: "fs",
+  SS: "ss",
+  FF: "ff",
+  SF: "sf"
+});
+
+// src/critical-path/legacy/constants/linkByCode.js
+function getLinkNameByCode(code) {
+  const linkMap = {
+    0: "fs",
+    1: "ss",
+    2: "ff",
+    3: "sf"
   };
-  for (const rootId of rootIds) visit(rootId);
-  return changedIds;
+  return linkMap[Number(code)] || "sf";
 }
 
-// src/init/initial-passes.ts
-async function runInitialPasses(deps) {
-  const { state, sector, scheduler, skipAutoSchedule, now } = deps;
-  recomputeCorrelativeIds(state);
-  if (sector.updateDurationForPrimaveraEndDate) {
-    recomputeDurationsFromDates(state);
-  }
-  normalizeLoadedConstraintDates(state);
-  recomputeCanonicalRealWork(state);
-  if (skipAutoSchedule) {
-    if (now) {
-      applyExpectedProgressLive(state, now);
-      applyStatusPass(state, sector.statusCriteria);
+// src/critical-path/legacy/base/identifiers/secondLevelActivities.js
+function identifySecondLevelActivities(params) {
+  const { gantt, pendingParentsWithNoLinks, calculations, linkProperty } = params;
+  try {
+    const subprojectsWithNoLinks = getSubprojectsWithNoLinks({
+      gantt,
+      pendingParentsWithNoLinks
+    });
+    if (subprojectsWithNoLinks.length === 0) {
+      return /* @__PURE__ */ new Set();
     }
-    return;
-  }
-  const result = await scheduler.schedule({});
-  applyResults(state, result);
-  normalizeMilestoneConstraintDatesForDisplay(state);
-  recomputeSkippedLeafEnds(state);
-  await updateParentBoundsFromChildren(state, void 0, false);
-  if (now) {
-    applyExpectedProgressLive(state, now);
-    applyStatusPass(state, sector.statusCriteria);
+    const allChildrenFromParents = getAllChildrenFromParents({
+      gantt,
+      subprojectsWithNoLinks
+    });
+    const childrenThatCanBeCalculated = filterChildrenThatCanBeCalculated({
+      gantt,
+      childrenIds: allChildrenFromParents,
+      linkProperty,
+      getArrayOfLinkedActivities,
+      calculations
+    });
+    return new Set(childrenThatCanBeCalculated.map((activity) => activity.id));
+  } catch (e) {
+    throw e;
   }
 }
-function applyExpectedProgressLive(state, now) {
-  const rootIds = [];
-  state.forEachActivity((activity, activityId) => {
-    if (activity.parentId === null) rootIds.push(activityId);
-  });
-  computeExpectedProgressLive(rootIds, now, state);
+function getSubprojectsWithNoLinks(params) {
+  const { gantt, pendingParentsWithNoLinks } = params;
+  return gantt.getTaskByTime().filter(filters_default.filterByParentType).filter((activity) => pendingParentsWithNoLinks.has(activity.id)).map((activity) => activity.id);
 }
-function recomputeSkippedLeafEnds(state) {
-  state.forEachActivity((activity) => {
-    if (activity.autoScheduling) return;
-    if (!activity.startDate || activity.durationHours == null) return;
-    if (state.getChildren(activity.id).length > 0) return;
-    activity.endDate = state.calculateEndDate({
-      startDate: activity.startDate,
-      durationHours: activity.durationHours,
-      task: activity
+function getAllChildrenFromParents(params) {
+  const { gantt, subprojectsWithNoLinks } = params;
+  const allChildrenSet = /* @__PURE__ */ new Set();
+  for (const subprojectId of subprojectsWithNoLinks) {
+    const childrenIds = gantt.getChildren(subprojectId);
+    const validChildren = childrenIds.filter((childId) => {
+      const childActivity = gantt.getTask(childId);
+      const isTaskOrMilestone = filters_default.byTaskTypeAndMilestone(childActivity);
+      const hasProgressLessThan100 = Number(childActivity.progress) < 100;
+      return isTaskOrMilestone && hasProgressLessThan100;
     });
-  });
+    validChildren.forEach((childId) => allChildrenSet.add(childId));
+  }
+  return [...allChildrenSet];
 }
-function recomputeDurationsFromDates(state) {
-  state.forEachActivity((activity) => {
-    if (!activity.startDate || !activity.endDate) return;
-    activity.durationHours = state.calculateDuration({
-      startDate: activity.startDate,
-      endDate: activity.endDate,
-      task: activity
+function filterChildrenThatCanBeCalculated(params) {
+  const {
+    gantt,
+    childrenIds,
+    linkProperty,
+    getArrayOfLinkedActivities: getArrayOfLinkedActivities3,
+    calculations
+  } = params;
+  const calculableChildren = [];
+  for (const childId of childrenIds) {
+    const activity = gantt.getTask(childId);
+    const links = activity[linkProperty] || [];
+    const linkedActivities = getArrayOfLinkedActivities3({
+      gantt,
+      links,
+      linkDirection: linkProperty === "$source" ? "target" : "source"
     });
-  });
-}
-function normalizeLoadedConstraintDates(state) {
-  state.forEachActivity((activity) => {
-    const type = activity.constraintType;
-    if (!type || !activity.constraintDate) return;
-    const constraintDate = activity.constraintDate;
-    if (activity.type === "milestone" && (constraintDate.getUTCHours() !== 0 || constraintDate.getUTCMinutes() !== 0)) {
-      return;
-    }
-    const calendar = state.calendarReader.getCalendar(
-      String(activity.calendarId)
-    );
-    if (!calendar) return;
-    activity.constraintDate = normalizeConstraintDate(
-      activity.constraintDate,
-      calendar,
-      type
-    );
-  });
-}
-function normalizeMilestoneConstraintDatesForDisplay(state) {
-  state.forEachActivity((activity) => {
-    if (activity.type !== "milestone") return;
-    const type = activity.constraintType;
-    if (!type || !activity.constraintDate) return;
-    const calendar = state.calendarReader.getCalendar(
-      String(activity.calendarId)
-    );
-    if (!calendar) return;
-    activity.constraintDate = normalizeConstraintDate(
-      activity.constraintDate,
-      calendar,
-      type
+    const isLinkedWithCalculatedOrSibling = linkedActivities.every(
+      (linkedActivityId) => calculations.has(linkedActivityId)
     );
-  });
+    if (isLinkedWithCalculatedOrSibling) {
+      calculableChildren.push(activity);
+    }
+  }
+  return calculableChildren;
 }
-
-// src/propagations/shared/get-active-baseline.ts
-function getActiveBaseline(activity) {
-  const points = activity?.baselinePoints;
-  if (!Array.isArray(points) || points.length === 0) return null;
-  return points.find((point) => point.isActiveVersion) ?? null;
+function getArrayOfLinkedActivities(params) {
+  const { gantt, links, linkDirection } = params;
+  const linkedActivityIds = [];
+  for (const linkId of links) {
+    const link = gantt.getLink(linkId);
+    if (!link) {
+      continue;
+    }
+    const linkedActivityId = Number(link[linkDirection]);
+    linkedActivityIds.push(linkedActivityId);
+  }
+  return linkedActivityIds;
 }
 
-// src/columns/expected-progress-base/compute.ts
-var isProject2 = (a) => a.type === "project";
-var activeBaselineOf = (a) => getActiveBaseline(a);
-var leafExpected = (a, now, adapter, defaultBaseCalendarId) => {
-  const base = activeBaselineOf(a);
-  if (!base) return 0;
-  const cal = (base.baseCalendarId != null ? adapter.getBaseCalendar(`${base.baseCalendarId}-base`) : null) ?? (defaultBaseCalendarId ? adapter.getBaseCalendar(defaultBaseCalendarId) : null);
-  if (!cal) return 0;
-  if (!base.startDate || !base.endDate) return 0;
-  return expectedProgressFromBaseline(base.startDate, base.endDate, now, cal);
-};
-function computeExpectedProgress(rootIds, now, adapter, defaultBaseCalendarId = null) {
-  const changed = [];
-  const writeIfChanged = (id, value) => {
-    const a = adapter.getActivity(id);
-    if (!a) return;
-    if (a.expectedProgressBaseline !== value) {
-      adapter.setActivityField(id, "expectedProgressBaseline", value);
-      changed.push(id);
-    }
-  };
-  const visit = (id) => {
-    const a = adapter.getActivity(id);
-    if (!a) return 0;
-    if (!isProject2(a)) {
-      const v2 = leafExpected(a, now, adapter, defaultBaseCalendarId);
-      writeIfChanged(id, v2);
-      return v2;
+// src/critical-path/legacy/base/identifiers/initialActivities.js
+function identifyInitialActivities({ gantt, linkProperty, direction }) {
+  try {
+    const chainStartActivities = getChainStartActivities(gantt, linkProperty);
+    if (direction === "forward") {
+      return {
+        chainStartActivities,
+        activitiesStartChainButChildrenOfLinkedParents: null
+      };
     }
-    let acc = 0;
-    for (const childId of adapter.getChildrenIds(id)) {
-      const childBase = visit(childId);
-      const child = adapter.getActivity(childId);
-      const weight = typeof child?.ponderator === "number" ? child.ponderator : 0;
-      acc += childBase * weight;
+    if (direction === "backward") {
+      return processBackwardActivities(
+        chainStartActivities,
+        gantt,
+        linkProperty
+      );
     }
-    const v = acc / 100;
-    writeIfChanged(id, v);
-    return v;
-  };
-  for (const id of rootIds) visit(id);
-  return changed;
-}
-function runExpectedProgressBase(state, now, defaultBaseCalendarId = null) {
-  const adapter = {
-    getChildrenIds: (parentId) => state.getChildren(String(parentId)).map((childId) => String(childId)),
-    getActivity: (id) => state.getActivity(id),
-    setActivityField: (id, field, value) => setActivityFieldDynamic(state, id, field, value),
-    getBaseCalendar: (engineId) => state.calendarReader.getCalendar(engineId)
-  };
-  const rootIds = [];
-  state.forEachActivity((activity, id) => {
-    if (activity.parentId === null) rootIds.push(id);
-  });
-  return computeExpectedProgress(rootIds, now, adapter, defaultBaseCalendarId);
-}
-
-// src/critical-path/legacy/shims/moment.js
-function moment(input) {
-  const d = input instanceof Date ? new Date(input.getTime()) : input && typeof input === "object" && typeof input.valueOf === "function" ? new Date(input.valueOf()) : new Date(input);
-  const accessor = (getUTC, setUTC) => (value) => {
-    if (value === void 0) return d[getUTC]();
-    d[setUTC](value);
-    return api;
-  };
-  const api = {
-    __isMomentShim: true,
-    clone: () => moment(d),
-    hours: accessor("getUTCHours", "setUTCHours"),
-    minutes: accessor("getUTCMinutes", "setUTCMinutes"),
-    seconds: accessor("getUTCSeconds", "setUTCSeconds"),
-    milliseconds: accessor("getUTCMilliseconds", "setUTCMilliseconds"),
-    valueOf: () => d.getTime(),
-    toDate: () => new Date(d.getTime()),
-    getTime: () => d.getTime()
-  };
-  return api;
-}
-moment.isMoment = (x) => Boolean(x) && typeof x === "object" && x.__isMomentShim === true;
-var moment_default = moment;
-
-// src/critical-path/legacy/helpers/isValidDate.js
-function isDate(obj) {
-  if (obj && obj.constructor === Date) {
-    return Boolean(obj.getFullYear && obj.getMonth && obj.getDate);
+  } catch (e) {
+    console.log("Critical Path", e);
+    throw e;
   }
-  return false;
 }
-function isValidDate2(obj) {
-  return isDate(obj) && !isNaN(obj.getTime());
+function getChainStartActivities(gantt, linkProperty) {
+  return gantt.getTaskByTime().filter(filters_default.avoidSubproject).filter(filters_default.byTaskTypeAndMilestone).filter((activity) => !activity[linkProperty].length);
 }
-
-// src/critical-path/legacy/helpers/addDurationToDate.js
-function addDurationToDate(activityCalendar, date2, duration, activity) {
-  if (!isValidDate2(new Date(date2))) {
-    throw new Error(
-      `Invalid date argument for calculateEndDate method. Date: ${date2}, Activity: ${JSON.stringify(activity)}`
-    );
-  }
-  const dateToCalculate = date2;
-  return activityCalendar.calculateEndDate({
-    start_date: new Date(dateToCalculate),
-    duration,
-    unit: "hour",
-    task: activity
+function processBackwardActivities(chainStartActivities, gantt, linkProperty) {
+  const withoutLinkedParents = [];
+  const activitiesStartChainButChildrenOfLinkedParents = /* @__PURE__ */ new Set();
+  chainStartActivities.forEach((activity) => {
+    const parentId = Number(activity.parent);
+    const parentActivity = gantt.getTask(parentId);
+    if (!parentActivity) return;
+    if (parentActivity[linkProperty].length > 0) {
+      activitiesStartChainButChildrenOfLinkedParents.add(activity.id);
+    } else if (parentActivity.constraint_type !== "fnlt") {
+      withoutLinkedParents.push(activity);
+    }
   });
-}
-
-// src/critical-path/legacy/helpers/getNextWorkingHour.js
-function getNextWorkingHour(activityParams) {
-  if (!isValidDate2(new Date(activityParams.dateBaseToCalculate))) {
-    throw new Error("Invalid date argument for getClosestWorkTime method");
-  }
-  const { dateBaseToCalculate, activityCalendar, direction, activity } = activityParams;
-  const newDate = activityCalendar.$gantt.getClosestWorkTime({
-    date: new Date(dateBaseToCalculate),
-    dir: direction,
-    unit: "hour",
-    task: activity
-  });
-  return newDate;
-}
-
-// src/critical-path/legacy/helpers/filters.js
-var byFirstLevel = (activity) => {
-  if (!activity) return false;
-  return activity["$level"] === 1;
-};
-var filterByParentType = (activity) => activity.type === "project";
-var avoidSubproject = (activity) => activity["$level"] !== 0;
-var byTaskType = (activity) => activity.type === "task";
-var byTaskTypeAndMilestone = (activity) => activity.type === "task" || activity.type === "milestone";
-var filters_default = {
-  byFirstLevel,
-  filterByParentType,
-  avoidSubproject,
-  byTaskType,
-  byTaskTypeAndMilestone
-};
-
-// src/critical-path/legacy/constants/constraints.js
-var CONSTRAINT_TYPES = Object.freeze({
-  MFO: "mfo",
-  MSO: "mso",
-  FNLT: "fnlt",
-  FNET: "fnet",
-  SNET: "snet",
-  SNLT: "snlt",
-  ALAP: "alap",
-  ASAP: "asap"
-});
-
-// src/critical-path/legacy/constants/linkTypes.js
-var LINK_TYPES = Object.freeze({
-  FS: "fs",
-  SS: "ss",
-  FF: "ff",
-  SF: "sf"
-});
-
-// src/critical-path/legacy/constants/linkByCode.js
-function getLinkNameByCode(code) {
-  const linkMap = {
-    0: "fs",
-    1: "ss",
-    2: "ff",
-    3: "sf"
-  };
-  return linkMap[Number(code)] || "sf";
-}
-
-// src/critical-path/legacy/base/identifiers/secondLevelActivities.js
-function identifySecondLevelActivities(params) {
-  const { gantt, pendingParentsWithNoLinks, calculations, linkProperty } = params;
-  try {
-    const subprojectsWithNoLinks = getSubprojectsWithNoLinks({
-      gantt,
-      pendingParentsWithNoLinks
-    });
-    if (subprojectsWithNoLinks.length === 0) {
-      return /* @__PURE__ */ new Set();
-    }
-    const allChildrenFromParents = getAllChildrenFromParents({
-      gantt,
-      subprojectsWithNoLinks
-    });
-    const childrenThatCanBeCalculated = filterChildrenThatCanBeCalculated({
-      gantt,
-      childrenIds: allChildrenFromParents,
-      linkProperty,
-      getArrayOfLinkedActivities,
-      calculations
-    });
-    return new Set(childrenThatCanBeCalculated.map((activity) => activity.id));
-  } catch (e) {
-    throw e;
-  }
-}
-function getSubprojectsWithNoLinks(params) {
-  const { gantt, pendingParentsWithNoLinks } = params;
-  return gantt.getTaskByTime().filter(filters_default.filterByParentType).filter((activity) => pendingParentsWithNoLinks.has(activity.id)).map((activity) => activity.id);
-}
-function getAllChildrenFromParents(params) {
-  const { gantt, subprojectsWithNoLinks } = params;
-  const allChildrenSet = /* @__PURE__ */ new Set();
-  for (const subprojectId of subprojectsWithNoLinks) {
-    const childrenIds = gantt.getChildren(subprojectId);
-    const validChildren = childrenIds.filter((childId) => {
-      const childActivity = gantt.getTask(childId);
-      const isTaskOrMilestone = filters_default.byTaskTypeAndMilestone(childActivity);
-      const hasProgressLessThan100 = Number(childActivity.progress) < 100;
-      return isTaskOrMilestone && hasProgressLessThan100;
-    });
-    validChildren.forEach((childId) => allChildrenSet.add(childId));
-  }
-  return [...allChildrenSet];
-}
-function filterChildrenThatCanBeCalculated(params) {
-  const {
-    gantt,
-    childrenIds,
-    linkProperty,
-    getArrayOfLinkedActivities: getArrayOfLinkedActivities3,
-    calculations
-  } = params;
-  const calculableChildren = [];
-  for (const childId of childrenIds) {
-    const activity = gantt.getTask(childId);
-    const links = activity[linkProperty] || [];
-    const linkedActivities = getArrayOfLinkedActivities3({
-      gantt,
-      links,
-      linkDirection: linkProperty === "$source" ? "target" : "source"
-    });
-    const isLinkedWithCalculatedOrSibling = linkedActivities.every(
-      (linkedActivityId) => calculations.has(linkedActivityId)
-    );
-    if (isLinkedWithCalculatedOrSibling) {
-      calculableChildren.push(activity);
-    }
-  }
-  return calculableChildren;
-}
-function getArrayOfLinkedActivities(params) {
-  const { gantt, links, linkDirection } = params;
-  const linkedActivityIds = [];
-  for (const linkId of links) {
-    const link = gantt.getLink(linkId);
-    if (!link) {
-      continue;
-    }
-    const linkedActivityId = Number(link[linkDirection]);
-    linkedActivityIds.push(linkedActivityId);
-  }
-  return linkedActivityIds;
-}
-
-// src/critical-path/legacy/base/identifiers/initialActivities.js
-function identifyInitialActivities({ gantt, linkProperty, direction }) {
-  try {
-    const chainStartActivities = getChainStartActivities(gantt, linkProperty);
-    if (direction === "forward") {
-      return {
-        chainStartActivities,
-        activitiesStartChainButChildrenOfLinkedParents: null
-      };
-    }
-    if (direction === "backward") {
-      return processBackwardActivities(
-        chainStartActivities,
-        gantt,
-        linkProperty
-      );
-    }
-  } catch (e) {
-    console.log("Critical Path", e);
-    throw e;
-  }
-}
-function getChainStartActivities(gantt, linkProperty) {
-  return gantt.getTaskByTime().filter(filters_default.avoidSubproject).filter(filters_default.byTaskTypeAndMilestone).filter((activity) => !activity[linkProperty].length);
-}
-function processBackwardActivities(chainStartActivities, gantt, linkProperty) {
-  const withoutLinkedParents = [];
-  const activitiesStartChainButChildrenOfLinkedParents = /* @__PURE__ */ new Set();
-  chainStartActivities.forEach((activity) => {
-    const parentId = Number(activity.parent);
-    const parentActivity = gantt.getTask(parentId);
-    if (!parentActivity) return;
-    if (parentActivity[linkProperty].length > 0) {
-      activitiesStartChainButChildrenOfLinkedParents.add(activity.id);
-    } else if (parentActivity.constraint_type !== "fnlt") {
-      withoutLinkedParents.push(activity);
-    }
-  });
-  return {
-    chainStartActivities: withoutLinkedParents,
-    activitiesStartChainButChildrenOfLinkedParents
-  };
+  return {
+    chainStartActivities: withoutLinkedParents,
+    activitiesStartChainButChildrenOfLinkedParents
+  };
 }
 
 // src/critical-path/legacy/base/identifiers/identifyParentsWithAndWithoutLinks.js
@@ -9491,13 +9425,18 @@ var NON_SCHEDULING_INLINE_COLUMNS = /* @__PURE__ */ new Set([
   COLUMN.SUBCONTRACT_ID,
   COLUMN.TAGS
 ]);
-var PROP_ONLY_KINDS = /* @__PURE__ */ new Set([
+var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "selection-toggle",
   "selection-replace",
   "visibility-set",
   "sir-sync",
-  "activity-lookahead-sync"
+  "activity-lookahead-sync",
+  "persistence-acknowledge",
+  "baseline-apply",
+  "ponderator-criterion-set",
+  "status-criteria-set"
 ]);
+var NO_STRUCTURAL_EXEMPTIONS = /* @__PURE__ */ new Set();
 function editsOnlyNonSchedulingColumns(action) {
   if (action.kind === "inline-edit") {
     return NON_SCHEDULING_INLINE_COLUMNS.has(action.column);
@@ -9510,11 +9449,14 @@ function editsOnlyNonSchedulingColumns(action) {
   return false;
 }
 function isSchedulingDispatch(action, structuralStaleKinds) {
-  if (PROP_ONLY_KINDS.has(action.kind)) return false;
+  if (NON_SCHEDULING_KINDS.has(action.kind)) return false;
   if (structuralStaleKinds.has(action.kind)) return false;
   if (editsOnlyNonSchedulingColumns(action)) return false;
   return true;
 }
+function dispatchChangesSchedulingState(action) {
+  return isSchedulingDispatch(action, NO_STRUCTURAL_EXEMPTIONS);
+}
 function resolveRunCriticalPath(action) {
   return isSchedulingDispatch(
     action,
@@ -9590,6 +9532,9 @@ function resolveDerivedPasses(action, autoSchedule, options) {
 // src/dispatch/shared/post-mutation.ts
 async function runPostMutation(deps, args) {
   const passes = resolvePasses(args);
+  if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
+    await refreshMutatedParentBounds(deps.adapter, args);
+  }
   const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(deps, args.autoscheduleFrom) : emptySchedule();
   await rollUpParentBounds(deps.adapter, args, schedule.scheduledIds, passes);
   await runDerivedRecomputes(deps, passes, args.now);
@@ -9598,7 +9543,11 @@ async function runPostMutation(deps, args) {
 function resolvePasses(args) {
   const requested = args.autoscheduleFrom !== null;
   const ran = !args.options.skipAutoSchedule && requested;
-  return resolveDerivedPasses(args.action, { ran }, args.options);
+  const passes = new Set(
+    resolveDerivedPasses(args.action, { ran }, args.options)
+  );
+  if (args.recomputeParentProgress) passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  return passes;
 }
 async function runAutoschedule(deps, autoscheduleFrom) {
   const options = autoscheduleFrom === "roots" ? {} : { triggerId: autoscheduleFrom };
@@ -9609,20 +9558,23 @@ async function runAutoschedule(deps, autoscheduleFrom) {
 }
 function captureScheduledRows(adapter, updatedIds) {
   const scheduledIds = [];
-  const scheduledBeforeImages = /* @__PURE__ */ new Map();
   for (const id of updatedIds) {
     const activityId = String(id);
     scheduledIds.push(activityId);
     const snap = adapter.getActivity(activityId);
     if (snap) {
-      scheduledBeforeImages.set(activityId, structuredCloneActivity(snap));
       adapter.noteScheduledBefore(activityId, snap);
     }
   }
-  return { scheduledIds, scheduledBeforeImages };
+  return { scheduledIds };
 }
 function emptySchedule() {
-  return { scheduledIds: [], scheduledBeforeImages: /* @__PURE__ */ new Map() };
+  return { scheduledIds: [] };
+}
+async function refreshMutatedParentBounds(adapter, args) {
+  const mutated = args.collectDirty ? args.collectDirty([]) : collectDirtyForStructural(args.recomputeParentsFrom, []);
+  if (mutated.size === 0) return;
+  await updateParentBoundsFromChildren(adapter, mutated, false);
 }
 async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
   const dirty = args.collectDirty ? args.collectDirty(scheduledIds) : collectDirtyForStructural(args.recomputeParentsFrom, scheduledIds);
@@ -9631,17 +9583,20 @@ async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
     dirty,
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
-      recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK)
+      recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
+      progressMode: args.recomputeParentProgress ? "zero-when-no-contribution" : "freeze-when-no-contribution"
     }
   );
 }
 async function runDerivedRecomputes(deps, passes, now) {
   if (passes.has(DERIVED_PASS.EXPECTED_PROGRESS) && now !== null) {
-    runExpectedProgressBase(
-      deps.adapter,
-      now,
-      deps.defaultBaseCalendarId ?? null
-    );
+    if (hasActiveBaseline(deps.adapter)) {
+      runExpectedProgressBase(
+        deps.adapter,
+        now,
+        deps.defaultBaseCalendarId ?? null
+      );
+    }
     applyExpectedProgressLive(deps.adapter, now);
     applyStatusPass(deps.adapter, deps.sector.statusCriteria);
   }
@@ -9652,6 +9607,13 @@ async function runDerivedRecomputes(deps, passes, now) {
     await applyCriticalPath(deps.adapter, deps.sector.hoursPerDay);
   }
 }
+function hasActiveBaseline(adapter) {
+  let active = false;
+  adapter.forEachActivity((activity) => {
+    if (getActiveBaseline(activity)) active = true;
+  });
+  return active;
+}
 
 // src/dispatch/handlers/revert-no-op-constraint-edit.ts
 var CONSTRAINT_EDIT_COLUMNS = /* @__PURE__ */ new Set([
@@ -9662,6 +9624,9 @@ var MUST_CONSTRAINTS = /* @__PURE__ */ new Set(["mso", "mfo"]);
 function isConstraintEditColumn(column) {
   return CONSTRAINT_EDIT_COLUMNS.has(column);
 }
+function isExplicitConstraintDateEdit(column) {
+  return column === COLUMN.CONSTRAINT_DATE;
+}
 function revertNoOpConstraintEdit(activityId, priorConstraintDate, adapter, calendars) {
   const activity = adapter.getActivity(activityId);
   if (!activity) return false;
@@ -9705,7 +9670,7 @@ function sameDate(first, second) {
 
 // src/dispatch/shared/constraint-settle.ts
 async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, revert }) {
-  let { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  let { scheduledIds } = await runPostMutation(
     deps,
     withCriticalPathSuppressed(postMutationArgs)
   );
@@ -9720,15 +9685,11 @@ async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, re
       withCriticalPathSuppressed(postMutationArgs)
     );
     scheduledIds = mergeScheduledIds(scheduledIds, resettled.scheduledIds);
-    scheduledBeforeImages = mergeScheduledBeforeImagesFirstWins(
-      scheduledBeforeImages,
-      resettled.scheduledBeforeImages
-    );
   }
   if (resolveRunCriticalPath(postMutationArgs.action)) {
     await runPostMutation(deps, criticalPathOnlyArgs(postMutationArgs));
   }
-  return { scheduledIds, scheduledBeforeImages };
+  return { scheduledIds };
 }
 function withCriticalPathSuppressed(args) {
   return {
@@ -9750,13 +9711,6 @@ function mergeScheduledIds(firstSettleIds, secondSettleIds) {
   for (const scheduledId of secondSettleIds) merged.add(scheduledId);
   return [...merged];
 }
-function mergeScheduledBeforeImagesFirstWins(firstSettleImages, secondSettleImages) {
-  const merged = new Map(firstSettleImages);
-  for (const [imageId, image] of secondSettleImages) {
-    if (!merged.has(imageId)) merged.set(imageId, image);
-  }
-  return merged;
-}
 
 // src/dispatch/sir-auto-reject.ts
 function datesChanged(before, after) {
@@ -9791,33 +9745,12 @@ function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
 
 // src/dispatch/shared/change-set.ts
 function assembleChangeSet(adapter, args) {
-  const allTouched = /* @__PURE__ */ new Set();
-  for (const id of args.touchedIds) allTouched.add(id);
-  for (const id of args.scheduledIds) allTouched.add(id);
-  if (args.includeAllIds) {
-    for (const id of adapter.getAllIds()) allTouched.add(id);
-  }
+  const allTouched = collectChangeSetIds(adapter, args);
   const before = new Map(args.beforeSnap);
   const captured = adapter.peekWriteCapture();
   if (captured) {
-    for (const id of captured.dirty) {
-      if (allTouched.has(id)) continue;
-      const beforeImg = captured.before.get(id);
-      const live = adapter.getActivity(id);
-      if (!beforeImg || !live) continue;
-      if (Object.keys(diffActivity(beforeImg, live)).length === 0) continue;
-      before.set(id, beforeImg);
-      allTouched.add(id);
-    }
-  }
-  if (args.scheduledBeforeImages) {
-    for (const [id, img] of args.scheduledBeforeImages) {
-      const sid = String(id);
-      if (!before.has(sid)) {
-        before.set(sid, img);
-        allTouched.add(sid);
-      }
-    }
+    const insertedIds = collectInsertedIds(captured);
+    mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
   const beforeDiffEffects = args.sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
   const activityChanges = buildActivityChanges(adapter, before, allTouched);
@@ -9834,6 +9767,31 @@ function assembleChangeSet(adapter, args) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+function collectChangeSetIds(adapter, args) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of args.touchedIds) ids.add(id);
+  for (const id of args.scheduledIds) ids.add(id);
+  if (args.includeAllIds) {
+    for (const id of adapter.getAllIds()) ids.add(id);
+  }
+  return ids;
+}
+function mergeDirtyBeforeImages(adapter, captured, insertedIds, before, touched) {
+  for (const id of captured.dirty) {
+    if (insertedIds.has(id) || before.has(id)) continue;
+    const beforeImage = captured.before.get(id);
+    const live = adapter.getActivity(id);
+    if (!beforeImage || !live) continue;
+    if (Object.keys(diffActivity(beforeImage, live)).length === 0) continue;
+    before.set(id, beforeImage);
+    touched.add(id);
+  }
+}
+function collectInsertedIds(captured) {
+  return new Set(
+    captured.ops.filter((operation) => operation.kind === "insert").map((operation) => operation.activityId)
+  );
+}
 
 // src/dispatch/conversion.ts
 function snapshotToLink(l) {
@@ -10016,7 +9974,8 @@ async function dispatchInlineEdit(action, options, deps) {
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
-    adapter
+    adapter,
+    beforeSnap.get(String(action.activityId)) ?? null
   );
   const linkChanges = diffIncomingLinkLagChanges(
     beforeLinkLags,
@@ -10041,7 +10000,7 @@ async function dispatchInlineEdit(action, options, deps) {
     options
   });
   const isConstraintPath = isConstraintEditColumn(action.column);
-  const { scheduledIds, scheduledBeforeImages } = await (isConstraintPath ? settleConstraintEdits(
+  const { scheduledIds } = await (isConstraintPath ? settleConstraintEdits(
     {
       adapter,
       scheduler,
@@ -10050,9 +10009,7 @@ async function dispatchInlineEdit(action, options, deps) {
     },
     {
       postMutationArgs: buildPostMutationArgs(),
-      revertTargets: [
-        { activityId: action.activityId, priorConstraintDate }
-      ],
+      revertTargets: isExplicitConstraintDateEdit(action.column) ? [] : [{ activityId: action.activityId, priorConstraintDate }],
       revert: (activityId, capturedConstraintDate) => revertNoOpConstraintEdit(
         activityId,
         capturedConstraintDate,
@@ -10084,7 +10041,6 @@ async function dispatchInlineEdit(action, options, deps) {
       beforeSnap,
       touchedIds,
       scheduledIds,
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       links: linkChanges,
       trackingEvents,
@@ -10098,6 +10054,40 @@ function columnInvalidatesExpandedLinks(column) {
 }
 
 // src/dispatch/handlers/link.ts
+function collectBatchContext(operations, adapter) {
+  const activityIds = /* @__PURE__ */ new Set();
+  const links = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    if (operation.kind === "create") {
+      activityIds.add(String(operation.source));
+      activityIds.add(String(operation.target));
+      continue;
+    }
+    const link = adapter.getLink(operation.linkId);
+    if (!link) continue;
+    activityIds.add(String(link.source));
+    activityIds.add(String(link.target));
+    links.set(operation.linkId, { ...link });
+  }
+  return { activityIds, links };
+}
+function applyBatchOperations(operations, adapter, linkIdGen, deterministicIds) {
+  return operations.map((operation, index) => {
+    const deterministicId = operation.kind === "create" ? deterministicIds?.get(index) : void 0;
+    const result = applyLinkOperation(operation, {
+      port: adapter,
+      newLinkId: deterministicId ? () => deterministicId : linkIdGen.next
+    });
+    return {
+      op: operation,
+      finalLinkId: result.applied ? result.linkId : null,
+      rejected: result.applied ? null : result.rejected ?? "link_op_rejected"
+    };
+  });
+}
+function stringKeyedLinkSnapshots(links) {
+  return new Map([...links].map(([id, link]) => [String(id), link]));
+}
 async function dispatchLink(action, options, deps) {
   if (action.kind === "link-create" || action.kind === "link-update") {
     const type = action.type;
@@ -10155,40 +10145,14 @@ function batchOpToLinkOperation(op, hoursPerDay) {
 async function dispatchLinkBatch(operations, source, options, deps, deterministicIds) {
   const { adapter, scheduler, sector, linkIdGen } = deps;
   scheduler.invalidateAllCaches();
-  const affectedActivityIds = /* @__PURE__ */ new Set();
-  const beforeLinks = /* @__PURE__ */ new Map();
-  for (const op of operations) {
-    if (op.kind === "create") {
-      affectedActivityIds.add(String(op.source));
-      affectedActivityIds.add(String(op.target));
-    } else {
-      const link = adapter.getLink(op.linkId);
-      if (link) {
-        affectedActivityIds.add(String(link.source));
-        affectedActivityIds.add(String(link.target));
-        beforeLinks.set(op.linkId, { ...link });
-      }
-    }
-  }
+  const { activityIds: affectedActivityIds, links: beforeLinks } = collectBatchContext(operations, adapter);
   const beforeActivities = snapshotActivities(adapter, affectedActivityIds);
-  const applied = [];
-  for (let i = 0; i < operations.length; i++) {
-    const op = operations[i];
-    const detId = op.kind === "create" && deterministicIds ? deterministicIds.get(i) : void 0;
-    const result = applyLinkOperation(op, {
-      port: adapter,
-      // Si el caller pasó un id deterministic (test override, o el bridge
-      // pasando el id que DHTMLX iba a usar), lo respetamos. Si no, el
-      // generador del core arranca desde Date.now() — mismo formato que
-      // DHTMLX uid(). Ver `generators/link-id-generator.ts`.
-      newLinkId: detId ? () => detId : linkIdGen.next
-    });
-    applied.push({
-      op,
-      finalLinkId: result.applied ? result.linkId : null,
-      rejected: result.applied ? null : result.rejected ?? "link_op_rejected"
-    });
-  }
+  const applied = applyBatchOperations(
+    operations,
+    adapter,
+    linkIdGen,
+    deterministicIds
+  );
   if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== "inline-edit") {
     return { ok: false, reason: applied[0].rejected };
   }
@@ -10208,21 +10172,24 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
       options
     }
   );
-  for (const id of scheduledIds) {
-    if (!beforeActivities.has(id)) {
-      const a = adapter.getActivity(id);
-      if (a) beforeActivities.set(id, structuredCloneActivity(a));
-    }
-  }
   const linkChanges = buildLinkChangesForBatch(applied, beforeLinks, adapter);
-  const beforeLinksByStringId = /* @__PURE__ */ new Map();
-  for (const [linkId, snap] of beforeLinks) {
-    beforeLinksByStringId.set(String(linkId), snap);
-  }
   return {
     ok: true,
-    __beforeLinks: beforeLinksByStringId,
-    changes: assembleChangeSet(adapter, {
+    linkVerdicts: applied.map(
+      (operation, operationIndex) => operation.rejected === null ? {
+        operationIndex,
+        kind: operation.op.kind,
+        ok: true,
+        linkId: String(operation.finalLinkId)
+      } : {
+        operationIndex,
+        kind: operation.op.kind,
+        ok: false,
+        reason: operation.rejected
+      }
+    ),
+    __beforeLinks: stringKeyedLinkSnapshots(beforeLinks),
+    changes: assembleChangeSet(adapter, {
       source,
       beforeSnap: beforeActivities,
       touchedIds: affectedActivityIds,
@@ -10233,26 +10200,21 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
   };
 }
 function pickAutoscheduleTrigger(applied, beforeLinks, adapter) {
-  for (const a of applied) {
-    if (a.rejected !== null) continue;
-    if (a.op.kind === "create") {
-      return adapter.hasChildren(a.op.target) ? "roots" : String(a.op.target);
-    }
-    if (a.op.kind === "delete") {
-      const snap = beforeLinks.get(a.op.linkId);
-      if (snap) {
-        return adapter.hasChildren(snap.target) ? "roots" : String(snap.target);
-      }
-    }
-    if (a.op.kind === "update") {
-      const link = adapter.getLink(a.op.linkId);
-      if (link) {
-        return adapter.hasChildren(link.target) ? "roots" : String(link.target);
-      }
-    }
+  for (const operation of applied) {
+    if (operation.rejected !== null) continue;
+    const target = autoscheduleTarget(operation.op, beforeLinks, adapter);
+    if (target !== null)
+      return adapter.hasChildren(target) ? "roots" : String(target);
   }
   return null;
 }
+function autoscheduleTarget(operation, beforeLinks, adapter) {
+  if (operation.kind === "create") return operation.target;
+  if (operation.kind === "delete") {
+    return beforeLinks.get(operation.linkId)?.target ?? null;
+  }
+  return adapter.getLink(operation.linkId)?.target ?? null;
+}
 function toLinkOperation(action, hoursPerDay) {
   if (action.kind === "link-create") {
     return {
@@ -10323,6 +10285,128 @@ var DISPATCH_TRACK_EVENT = {
   ACTIVITY_OUTDENT: "schedule_activity_outdent"
 };
 
+// src/internal/hierarchy/visual-order.ts
+var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
+function getChildrenInVisualOrder(parentId, adapter) {
+  const children = collectChildrenSnapshots(parentId, adapter);
+  children.sort(compareActivitiesInVisualOrder);
+  return children.map((a) => String(a.id));
+}
+function iterateInVisualOrder(adapter) {
+  const result = [];
+  const visit = (activity) => {
+    result.push(activity);
+    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
+    for (const childId of childIds) {
+      const child = adapter.getActivity(childId);
+      if (child) visit(child);
+    }
+  };
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  for (const rootId of rootIds) {
+    const root = adapter.getActivity(rootId);
+    if (root) visit(root);
+  }
+  return result;
+}
+function findPreviousNonSelectedSibling(taskId, selected, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return null;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  const idx = siblings.findIndex((id) => String(id) === String(taskId));
+  if (idx <= 0) return null;
+  for (let i = idx - 1; i >= 0; i--) {
+    const candidateId = siblings[i];
+    if (candidateId === void 0) continue;
+    if (!setHas(selected, candidateId)) return candidateId;
+  }
+  return null;
+}
+function visualIndexInParent(taskId, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return -1;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  return siblings.findIndex((id) => String(id) === String(taskId));
+}
+function collectChildrenSnapshots(parentId, adapter) {
+  const key = String(parentId);
+  if (key === "0") {
+    return adapter.getAllActivities().filter((a) => a.parentId === null);
+  }
+  const childIds = adapter.getChildren(parentId);
+  const out = [];
+  for (const id of childIds) {
+    const snap = adapter.getActivity(id);
+    if (snap) out.push(snap);
+  }
+  return out;
+}
+function compareActivitiesInVisualOrder(a, b) {
+  const ac = correlativeIdOf(a);
+  const bc = correlativeIdOf(b);
+  if (ac !== bc) return ac - bc;
+  return String(a.id).localeCompare(String(b.id));
+}
+function correlativeIdOf(activity) {
+  const raw = activity.correlativeId;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
+}
+function parentKeyOf(activity) {
+  const parentId = activity.parentId;
+  if (parentId === null) return "0";
+  return parentId;
+}
+function setHas(set, id) {
+  if (set.has(id)) return true;
+  return set.has(String(id));
+}
+
+// src/internal/hierarchy/recompute-correlative-ids.ts
+function recomputeCorrelativeIds(adapter) {
+  adapter.invalidateVisualOrderIds?.();
+  const roots = [];
+  adapter.forEachActivity((activity) => {
+    if (isRootParent(activity.parentId)) roots.push(activity);
+  });
+  roots.sort(byCorrelativeId);
+  const stack = [];
+  pushInReverseOrder(stack, roots);
+  const shifts = [];
+  let counter = 0;
+  while (stack.length > 0) {
+    const activity = stack.pop();
+    if (activity.correlativeId !== counter) {
+      const before = typeof activity.correlativeId === "number" ? activity.correlativeId : void 0;
+      shifts.push({ activityId: String(activity.id), before });
+      if (before !== void 0)
+        adapter.noteCorrelativeBefore?.(String(activity.id), before);
+      setCorrelativeId(activity, counter);
+    }
+    counter += 1;
+    const children = collectChildrenSnapshots(String(activity.id), adapter);
+    children.sort(byCorrelativeId);
+    pushInReverseOrder(stack, children);
+  }
+  return shifts;
+}
+function pushInReverseOrder(stack, activities) {
+  for (let i = activities.length - 1; i >= 0; i -= 1) {
+    stack.push(activities[i]);
+  }
+}
+function getCorrelativeId(activity) {
+  const raw = activity.correlativeId;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
+}
+var byCorrelativeId = (a, b) => getCorrelativeId(a) - getCorrelativeId(b);
+function setCorrelativeId(activity, value) {
+  activity.correlativeId = value;
+}
+
 // src/propagations/upward/recompute-hh-cascade.ts
 function recomputeHhCascadeForParent(startParentId, adapter) {
   if (!startParentId || startParentId === "0") return;
@@ -10477,8 +10561,7 @@ var NEW_ACTIVITY_DEFAULTS = Object.freeze({
   expectedProgress: null,
   expectedProgressBaseline: null,
   status: null,
-  criticalPath: null,
-  promotionRestore: null
+  criticalPath: null
 });
 var FIRST_ACTIVITY_TEXT = "New Master Plan";
 var NEW_ACTIVITY_TEXT = "New Activity";
@@ -10583,6 +10666,23 @@ function resolveStartDate(parent, fallback, override) {
 }
 
 // src/creation/parent-mutation-pipeline.ts
+function snapshotOf(parent) {
+  const type = parent.type;
+  if (type !== "task" && type !== "milestone") return null;
+  const startDate = parent.startDate;
+  const endDate = parent.endDate;
+  if (!(startDate instanceof Date) || !(endDate instanceof Date)) return null;
+  return {
+    type,
+    startDate: new Date(startDate),
+    endDate: new Date(endDate),
+    durationHours: Number(parent.durationHours ?? 0),
+    expectedProgressBaseline: typeof parent.expectedProgressBaseline === "number" ? parent.expectedProgressBaseline : null,
+    constraintType: parent.constraintType ?? null,
+    constraintDate: parent.constraintDate instanceof Date ? new Date(parent.constraintDate) : null,
+    progress: Number(parent.progress ?? 0)
+  };
+}
 function buildParentMutations(input) {
   const parent = input.getParent(input.parentId);
   if (!parent) return null;
@@ -10601,14 +10701,18 @@ function buildParentMutations(input) {
   }
   if (wasPromotableLeaf) {
     fields.type = PROMOTION_TARGET_TYPE;
-    fields.constraintType = CONSTRAINT_TYPE2.ASAP;
-    fields.constraintDate = null;
     if ((input.promotionSource ?? "create") === "create") {
+      fields.constraintType = CONSTRAINT_TYPE2.ASAP;
+      fields.constraintDate = null;
       fields.progress = 0;
       fields.expectedProgressBaseline = 0;
     }
   }
-  return { parentId: input.parentId, fields };
+  return {
+    parentId: input.parentId,
+    fields,
+    promotionSnapshot: snapshotOf(parent)
+  };
 }
 function isPromotableLeaf(parent) {
   return isPromotableLeafType(parent.type) && (!Array.isArray(parent.newActivityIds) || parent.newActivityIds.length === 0);
@@ -10834,6 +10938,12 @@ function applyParentMutations(action, newId, parent, adapter, preserveParentCust
     if (skipCustomIdMutation) continue;
     setActivityFieldDynamic(adapter, parentMutations.parentId, key, value);
   }
+  if (parentMutations.promotionSnapshot) {
+    adapter.setPromotionSnapshot(
+      parentMutations.parentId,
+      parentMutations.promotionSnapshot
+    );
+  }
 }
 function recomputeAndFoldCorrelatives(adapter, newId, beforeSnap, initialTouched, opts) {
   if (opts.skipCorrelativeRecompute) return;
@@ -10847,7 +10957,7 @@ function recomputeAndFoldCorrelatives(adapter, newId, beforeSnap, initialTouched
     initialTouched
   );
 }
-function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay, scheduledBeforeImages) {
+function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay) {
   const { newId, newActivity, beforeSnap, initialTouched } = coreResult;
   const trackingEvent = {
     name: DISPATCH_TRACK_EVENT.ACTIVITY_CREATION,
@@ -10860,40 +10970,13 @@ function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPe
   if (action.eventSource !== void 0) {
     trackingEvent.properties.event_source = action.eventSource;
   }
-  const existingScheduledBeforeImages = scheduledBeforeImages ? new Map(
-    [...scheduledBeforeImages].filter(
-      ([scheduledId]) => String(scheduledId) !== String(newId)
-    )
-  ) : void 0;
   return assembleChangeSet(adapter, {
     source: action,
     beforeSnap,
     touchedIds: initialTouched,
     scheduledIds,
-    scheduledBeforeImages: existingScheduledBeforeImages,
     trackingEvents: [trackingEvent]});
 }
-function createActivitySync(action, deps) {
-  const result = createActivityCore(action, deps);
-  if (!result.ok) {
-    return { ok: false, reason: result.reason };
-  }
-  recomputeParentBoundsSync(deps.adapter, /* @__PURE__ */ new Set([result.newId]));
-  const snapshot = deps.adapter.getActivity(result.newId);
-  if (!snapshot) {
-    throw new Error(
-      `[ScheduleCore] createActivity: new activity ${result.newId} missing after commit`
-    );
-  }
-  const changes = buildCreateChangeSet(
-    deps.adapter,
-    action,
-    result,
-    [],
-    deps.sector.hoursPerDay
-  );
-  return { ok: true, activity: snapshot, changes };
-}
 async function dispatchActivityCreate(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
   const core = createActivityCore(action, deps);
@@ -10921,14 +11004,13 @@ async function dispatchActivityCreate(action, options, deps) {
   } finally {
     adapter.setActivityField(newId, "autoScheduling", createdAutoScheduling);
   }
-  const { scheduledIds, scheduledBeforeImages } = scheduleOutcome;
+  const { scheduledIds } = scheduleOutcome;
   const changeset = buildCreateChangeSet(
     adapter,
     action,
     core,
     scheduledIds,
-    sector.hoursPerDay,
-    scheduledBeforeImages
+    sector.hoursPerDay
   );
   return { ok: true, changes: changeset };
 }
@@ -11073,7 +11155,7 @@ async function dispatchActivityPaste(action, options, deps) {
       rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
     });
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11100,14 +11182,6 @@ async function dispatchActivityPaste(action, options, deps) {
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      // Existing rows the autoscheduler moved need a before-image (the global
-      // beforeSnap used to supply it). Pass scheduledBeforeImages but filter out
-      // the pasted rows — their pre-schedule image would flip them to `updated`.
-      scheduledBeforeImages: new Map(
-        [...scheduledBeforeImages].filter(
-          ([schedId]) => !createdIdSet.has(String(schedId))
-        )
-      ),
       links: linkChanges,
       hoursPerDay: sector.hoursPerDay
     })
@@ -11242,10 +11316,8 @@ function collectIncidentLinkIds(activityIds, adapter) {
 }
 
 // src/internal/hierarchy/parent-demotion.ts
-function restoredPromotionFields(parent) {
-  const restore = parent.promotionRestore;
-  if (typeof restore !== "object" || restore === null) return null;
-  if (restore.type !== "task" && restore.type !== "milestone") return null;
+function restoredPromotionFields(restore) {
+  if (!restore) return null;
   return {
     type: restore.type,
     startDate: new Date(restore.startDate),
@@ -11254,16 +11326,20 @@ function restoredPromotionFields(parent) {
     expectedProgressBaseline: restore.expectedProgressBaseline,
     constraintType: restore.constraintType,
     constraintDate: restore.constraintDate ? new Date(restore.constraintDate) : null,
-    progress: restore.progress,
-    promotionRestore: null
+    progress: restore.progress
   };
 }
+function canonicalEndDateField(parent, durationHours, computeEndDate) {
+  const startDate = parent.startDate;
+  if (!computeEndDate || !(startDate instanceof Date)) return {};
+  return { endDate: computeEndDate(startDate, durationHours) };
+}
 function buildParentDemotionMutations(input) {
   if (input.remainingChildIds.length > 0) return null;
   const parent = input.parent;
   const canonicalDuration = input.defaultDurationHours;
   const hasCanonicalDefaults = Number.isFinite(canonicalDuration);
-  const fields = restoredPromotionFields(parent) ?? (hasCanonicalDefaults ? {
+  const fields = restoredPromotionFields(input.promotionSnapshot) ?? (hasCanonicalDefaults ? {
     type: DEMOTION_TARGET_TYPE,
     durationHours: canonicalDuration,
     progress: 0,
@@ -11271,7 +11347,11 @@ function buildParentDemotionMutations(input) {
     constraintType: "asap",
     constraintDate: null,
     hasNewActivities: false,
-    promotionRestore: null
+    ...canonicalEndDateField(
+      parent,
+      canonicalDuration,
+      input.computeEndDate
+    )
   } : { type: DEMOTION_TARGET_TYPE });
   if (input.idsRemoved && input.idsRemoved.size > 0) {
     const existing = Array.isArray(parent.newActivityIds) ? parent.newActivityIds : [];
@@ -11368,6 +11448,8 @@ async function dispatchActivityDelete(action, options, deps) {
       parent,
       remainingChildIds: remainingChildren.map(String),
       defaultDurationHours: sector.hoursPerDay,
+      promotionSnapshot: adapter.getPromotionSnapshot(parentId),
+      computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({ startDate, durationHours, task: parent }),
       idsRemoved: toDelete
     });
     if (!demotion) {
@@ -11403,7 +11485,7 @@ async function dispatchActivityDelete(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11440,7 +11522,6 @@ async function dispatchActivityDelete(action, options, deps) {
     beforeSnap,
     touchedIds,
     scheduledIds,
-    scheduledBeforeImages,
     sirDetection: "after-diff",
     links: buildLinkDeletions(beforeLinks),
     trackingEvents: [trackingEvent],
@@ -11612,6 +11693,12 @@ async function dispatchActivityMove(action, options, deps) {
           for (const [key, value] of Object.entries(promotion.fields)) {
             setActivityFieldDynamic(adapter, promotion.parentId, key, value);
           }
+          if (promotion.promotionSnapshot) {
+            adapter.setPromotionSnapshot(
+              promotion.parentId,
+              promotion.promotionSnapshot
+            );
+          }
           if (promotion.fields.customId === null) {
             releaseClearedCustomId(oldNewParentCustomId, deps.customIdTracker);
           }
@@ -11626,6 +11713,12 @@ async function dispatchActivityMove(action, options, deps) {
           parent: oldParentActivity,
           remainingChildIds: remaining.map(String),
           defaultDurationHours: sector.hoursPerDay,
+          promotionSnapshot: adapter.getPromotionSnapshot(oldParentKey),
+          computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({
+            startDate,
+            durationHours,
+            task: oldParentActivity
+          }),
           idsRemoved: /* @__PURE__ */ new Set([action.activityId])
         });
         if (demotion) {
@@ -11665,7 +11758,8 @@ async function dispatchActivityMove(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const sourceParentDirtyIds = parentChanged && oldParentKey !== ROOT_PARENT_ID ? adapter.getChildren(oldParentKey).map(String) : [];
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11675,9 +11769,14 @@ async function dispatchActivityMove(action, options, deps) {
     {
       action,
       autoscheduleFrom: action.activityId,
-      recomputeParentsFrom: [action.activityId, action.parentId],
+      recomputeParentsFrom: [
+        action.activityId,
+        action.parentId,
+        ...sourceParentDirtyIds
+      ],
       now: deps.now,
-      options
+      options,
+      recomputeParentProgress: parentChanged
     }
   );
   const invalidLinkIds = parentChanged ? collectInvalidLinkIdsForCycle([action.activityId], adapter) : [];
@@ -11701,7 +11800,6 @@ async function dispatchActivityMove(action, options, deps) {
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
@@ -11791,6 +11889,12 @@ async function dispatchActivityIndent(action, options, deps) {
       for (const [key, value] of Object.entries(promotion.fields)) {
         setActivityFieldDynamic(adapter, promotion.parentId, key, value);
       }
+      if (promotion.promotionSnapshot) {
+        adapter.setPromotionSnapshot(
+          promotion.parentId,
+          promotion.promotionSnapshot
+        );
+      }
       if (!wasTrackedAsNewChild) {
         adapter.setActivityField(
           newParentId,
@@ -11836,7 +11940,7 @@ async function dispatchActivityIndent(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11893,12 +11997,21 @@ async function dispatchActivityIndent(action, options, deps) {
   }
   return {
     ok: true,
+    activityVerdicts: action.activityIds.map((activityId) => {
+      const failure = failed.find(
+        (entry) => String(entry.activityId) === String(activityId)
+      );
+      return failure ? {
+        activityId: String(activityId),
+        ok: false,
+        reason: failure.reason
+      } : { activityId: String(activityId), ok: true };
+    }),
     changes: assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
@@ -12020,6 +12133,12 @@ async function dispatchActivityOutdent(action, options, deps) {
       parent: parentActivity,
       remainingChildIds: remaining.map(String),
       defaultDurationHours: sector.hoursPerDay,
+      promotionSnapshot: adapter.getPromotionSnapshot(oldParentKey),
+      computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({
+        startDate,
+        durationHours,
+        task: parentActivity
+      }),
       idsRemoved: new Set(
         planned.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
       )
@@ -12065,7 +12184,7 @@ async function dispatchActivityOutdent(action, options, deps) {
     if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
     beforeSnap.set(shift.activityId, beforeImage);
   }
-  const { scheduledIds, scheduledBeforeImages } = await runPostMutation(
+  const { scheduledIds } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -12098,12 +12217,21 @@ async function dispatchActivityOutdent(action, options, deps) {
   }
   return {
     ok: true,
+    activityVerdicts: action.activityIds.map((activityId) => {
+      const failure = failed.find(
+        (entry) => String(entry.activityId) === String(activityId)
+      );
+      return failure ? {
+        activityId: String(activityId),
+        ok: false,
+        reason: failure.reason
+      } : { activityId: String(activityId), ok: true };
+    }),
     changes: assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
       scheduledIds,
-      scheduledBeforeImages,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
@@ -12195,11 +12323,15 @@ async function dispatchDatesBatch(action, options, deps) {
     mergeBeforeSnapshots(beforeSnap, editTouched, deps);
     for (const id of editTouched) touchedIds.add(id);
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
+    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+      String(edit.activityId)
+    ) ?? null;
     applyFieldChanges(adapter, edit.activityId, outcome.changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
       outcome.changes.postProcessors ?? [],
-      adapter
+      adapter,
+      preEditSnapshot
     );
     linkChanges.push(
       ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
@@ -12334,6 +12466,7 @@ async function dispatchBulkEdit(action, options, deps) {
   const verdicts = [];
   const beforeSnap = /* @__PURE__ */ new Map();
   const constraintPriorsByActivity = /* @__PURE__ */ new Map();
+  const explicitDateEditActivities = /* @__PURE__ */ new Set();
   const touchedIds = /* @__PURE__ */ new Set();
   const trackingEvents = [];
   const linkChanges = [];
@@ -12352,14 +12485,21 @@ async function dispatchBulkEdit(action, options, deps) {
     mergeBeforeSnapshots2(beforeSnap, editTouched, deps);
     for (const touchedId of editTouched) touchedIds.add(touchedId);
     recordConstraintPrior(constraintPriorsByActivity, edit, beforeSnap);
+    if (isExplicitConstraintDateEdit(edit.column)) {
+      explicitDateEditActivities.add(String(edit.activityId));
+    }
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
+    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+      String(edit.activityId)
+    ) ?? null;
     const customIdBeforeApply = readLiveCustomId(edit, deps);
     const changes = outcome.changes;
     applyFieldChanges(adapter, edit.activityId, changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
       outcome.changes.postProcessors ?? [],
-      adapter
+      adapter,
+      preEditSnapshot
     );
     syncCustomIdTracker(edit, customIdBeforeApply, deps);
     linkChanges.push(
@@ -12381,7 +12521,7 @@ async function dispatchBulkEdit(action, options, deps) {
     options
   };
   const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
-  const { scheduledIds, scheduledBeforeImages } = await (batchHasConstraintEdits ? settleConstraintEdits(
+  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
     {
       adapter,
       scheduler,
@@ -12390,12 +12530,12 @@ async function dispatchBulkEdit(action, options, deps) {
     },
     {
       postMutationArgs,
-      revertTargets: [...constraintPriorsByActivity].map(
-        ([activityId, priorConstraintDate]) => ({
-          activityId,
-          priorConstraintDate
-        })
-      ),
+      revertTargets: [...constraintPriorsByActivity].filter(
+        ([activityId]) => !explicitDateEditActivities.has(activityId)
+      ).map(([activityId, priorConstraintDate]) => ({
+        activityId,
+        priorConstraintDate
+      })),
       revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
         activityId,
         priorConstraintDate,
@@ -12423,7 +12563,6 @@ async function dispatchBulkEdit(action, options, deps) {
       // Los dependientes que mueve el autoscheduler no están en beforeSnap;
       // sin su before-image el diff los marca FALSE-CREATED y el undo los
       // borra (fix 4bbccbc de inline-edit).
-      scheduledBeforeImages,
       sirDetection: "before-diff",
       links: linkChanges,
       trackingEvents,
@@ -12558,8 +12697,515 @@ function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
   }
 }
 
+// src/dispatch/handlers/persistence-acknowledge.ts
+function assertValidAssignment(assignment, entityName, readCurrent, ownerByBackendId, seenIds, seenBackendIds) {
+  const id = String(assignment.id);
+  if (id.length === 0 || seenIds.has(id)) {
+    throw new Error(
+      `persistence-acknowledge: duplicate or empty ${entityName} id "${id}"`
+    );
+  }
+  if (!Number.isSafeInteger(assignment.proplannerId) || assignment.proplannerId <= 0) {
+    throw new Error(
+      `persistence-acknowledge: invalid ${entityName} proplannerId ${String(assignment.proplannerId)}`
+    );
+  }
+  if (seenBackendIds.has(assignment.proplannerId)) {
+    throw new Error(
+      `persistence-acknowledge: duplicate ${entityName} proplannerId ${String(assignment.proplannerId)}`
+    );
+  }
+  const state = readCurrent(id);
+  if (!state.exists) {
+    throw new Error(
+      `persistence-acknowledge: unknown ${entityName} id "${id}"`
+    );
+  }
+  if (state.current !== null && state.current !== assignment.proplannerId) {
+    throw new Error(
+      `persistence-acknowledge: ${entityName} "${id}" already has proplannerId ${String(state.current)}`
+    );
+  }
+  const existingOwner = ownerByBackendId.get(assignment.proplannerId);
+  if (existingOwner !== void 0 && existingOwner !== id) {
+    throw new Error(
+      `persistence-acknowledge: ${entityName} proplannerId ${String(assignment.proplannerId)} already belongs to "${existingOwner}"`
+    );
+  }
+  seenIds.add(id);
+  seenBackendIds.add(assignment.proplannerId);
+}
+function assertValidAssignments(assignments, entityName, readCurrent, ownerByBackendId) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenBackendIds = /* @__PURE__ */ new Set();
+  for (const assignment of assignments) {
+    assertValidAssignment(
+      assignment,
+      entityName,
+      readCurrent,
+      ownerByBackendId,
+      seenIds,
+      seenBackendIds
+    );
+  }
+}
+function dispatchPersistenceAcknowledge(action, deps) {
+  const activities = action.activities ?? [];
+  const links = action.links ?? [];
+  const activityOwnerByBackendId = /* @__PURE__ */ new Map();
+  for (const activity of deps.adapter.getAllActivities()) {
+    if (activity.proplannerId != null) {
+      activityOwnerByBackendId.set(activity.proplannerId, String(activity.id));
+    }
+  }
+  const linkOwnerByBackendId = /* @__PURE__ */ new Map();
+  for (const link of deps.adapter.getAllLinks()) {
+    if (link.proplannerId != null) {
+      linkOwnerByBackendId.set(link.proplannerId, String(link.id));
+    }
+  }
+  assertValidAssignments(
+    activities,
+    "activity",
+    (id) => {
+      const activity = deps.adapter.getActivity(id);
+      return {
+        exists: activity !== null,
+        current: activity?.proplannerId ?? null
+      };
+    },
+    activityOwnerByBackendId
+  );
+  assertValidAssignments(
+    links,
+    "link",
+    (id) => {
+      const link = deps.adapter.getLink(id);
+      return { exists: link !== null, current: link?.proplannerId ?? null };
+    },
+    linkOwnerByBackendId
+  );
+  const activityChanges = [];
+  const linkChanges = [];
+  deps.adapter.batchUpdate(() => {
+    for (const assignment of activities) {
+      const before = deps.adapter.getActivity(assignment.id);
+      if (!before || before.proplannerId === assignment.proplannerId) continue;
+      deps.adapter.setActivityField(
+        assignment.id,
+        "proplannerId",
+        assignment.proplannerId
+      );
+      activityChanges.push({
+        id: assignment.id,
+        kind: "updated",
+        fields: {
+          proplannerId: {
+            before: before.proplannerId,
+            after: assignment.proplannerId
+          }
+        },
+        after: { ...before, proplannerId: assignment.proplannerId }
+      });
+    }
+    for (const assignment of links) {
+      const before = deps.adapter.getLink(assignment.id);
+      if (!before || before.proplannerId === assignment.proplannerId) continue;
+      deps.adapter.setLinkProplannerId(assignment.id, assignment.proplannerId);
+      linkChanges.push({
+        id: assignment.id,
+        kind: "updated",
+        fields: {
+          proplannerId: {
+            before: before.proplannerId,
+            after: assignment.proplannerId
+          }
+        },
+        after: { ...before, proplannerId: assignment.proplannerId }
+      });
+    }
+  });
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: activityChanges,
+      links: linkChanges,
+      calendars: [],
+      trackingEvents: []
+    }
+  };
+}
+
+// src/baselines/normalize-baseline-point.ts
+function parseBaselineDate(value) {
+  return typeof value === "string" && value.length > 0 ? parseBackendDate(value) : value instanceof Date ? value : null;
+}
+function parseFiniteNonNegative(value) {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+  if (!Number.isFinite(numeric) || numeric < 0) return null;
+  return numeric;
+}
+function normalizeBaselinePoint(point, reporter) {
+  const durationDays = parseFiniteNonNegative(point.duration);
+  const cost = parseFiniteNonNegative(point.cost);
+  const workHours = parseFiniteNonNegative(point.hh_work);
+  if (durationDays === null || cost === null || workHours === null) {
+    reporter.warn(
+      `[baseline] dropping point with non-finite/negative magnitude \u2014 duration=${JSON.stringify(point.duration)}, cost=${JSON.stringify(point.cost)}, hh_work=${JSON.stringify(point.hh_work)}`
+    );
+    return null;
+  }
+  return {
+    startDate: parseBaselineDate(point.start_date),
+    endDate: parseBaselineDate(point.end_date),
+    durationDays,
+    cost,
+    workHours,
+    versionId: typeof point.sectorbaselineversionId === "number" ? point.sectorbaselineversionId : null,
+    isActiveVersion: Boolean(point.sectorbaselineversion?.active),
+    isVisibleVersion: Boolean(point.sectorbaselineversion?.visible),
+    baseCalendarId: point.baseCalendarId != null ? String(point.baseCalendarId) : null,
+    hoursPerDay: typeof point.hoursPerDay === "number" ? point.hoursPerDay : null,
+    hoursPerWeek: typeof point.hoursPerWeek === "number" ? point.hoursPerWeek : null
+  };
+}
+
+// src/baselines/apply-baseline-points.ts
+function applyBaselinePoints(adapter, points, reporter) {
+  const idByProplanner = /* @__PURE__ */ new Map();
+  adapter.forEachActivity((a, id) => {
+    const pid = a.proplannerId;
+    if (typeof pid === "number") idByProplanner.set(pid, id);
+  });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const activityId = p.activityId;
+    if (typeof activityId !== "number") continue;
+    const coreId = idByProplanner.get(activityId);
+    if (coreId === void 0) continue;
+    const arr = grouped.get(coreId);
+    if (arr) arr.push(p);
+    else grouped.set(coreId, [p]);
+  }
+  const changed = [];
+  for (const [coreId, group] of grouped) {
+    adapter.setActivityField(
+      coreId,
+      "baselinePoints",
+      group.map((point) => normalizeBaselinePoint(point, reporter)).filter((point) => point !== null)
+    );
+    changed.push(coreId);
+  }
+  adapter.forEachActivity((a, id) => {
+    if (grouped.has(id)) return;
+    const existing = a.baselinePoints;
+    if (Array.isArray(existing) && existing.length > 0) {
+      adapter.setActivityField(id, "baselinePoints", []);
+      changed.push(id);
+    }
+  });
+  return changed;
+}
+
+// src/baselines/baseline-snapshot.ts
+function buildBaselineSnapshot(activity) {
+  const active = getActiveBaseline(activity);
+  if (!active) return null;
+  return {
+    startDate: active.startDate,
+    endDate: active.endDate,
+    durationDays: active.durationDays,
+    cost: active.cost,
+    workHours: active.workHours
+  };
+}
+function emitBaselineSnapshotColumns(state) {
+  const changed = [];
+  state.forEachActivity((activity, id) => {
+    const snapshot = buildBaselineSnapshot(activity);
+    if (!snapshot) {
+      if (activity.baselineSnapshot !== null) {
+        state.setActivityField(id, "baselineSnapshot", null);
+        changed.push(id);
+      }
+      return;
+    }
+    state.setActivityField(id, "baselineSnapshot", snapshot);
+    changed.push(id);
+  });
+  return changed;
+}
+
+// src/baselines/apply-baseline-overlay.ts
+function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarId = null) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const id of applyBaselinePoints(
+    state,
+    points,
+    reporter
+  )) {
+    changed.add(id);
+  }
+  if (now) {
+    for (const id of runExpectedProgressBase(state, now, defaultBaseCalendarId))
+      changed.add(id);
+  }
+  for (const id of emitBaselineSnapshotColumns(state)) changed.add(id);
+  for (const id of emitRealCost(state)) changed.add(id);
+  return [...changed];
+}
+
+// src/propagations/downward/recompute-ponderator-for-parent.ts
+function recomputePonderatorsForParent(parentId, criterion, adapter) {
+  if (!parentId || parentId === "0") return;
+  const childIds = adapter.getChildren(parentId);
+  if (childIds.length === 0) return;
+  const pesoById = /* @__PURE__ */ new Map();
+  let denominator = 0;
+  for (const childId of childIds) {
+    const peso = criterionValue(String(childId), criterion, adapter);
+    pesoById.set(String(childId), peso);
+    denominator += peso;
+  }
+  const relationValue = denominator ? 100 / denominator : 0;
+  for (const childId of childIds) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    const points = child.baselinePoints;
+    const active = getActiveBaseline(child);
+    if (active) {
+      const peso = pesoById.get(String(childId)) ?? 0;
+      adapter.setActivityField(
+        childId,
+        COLUMN.PONDERATOR,
+        relationValue * peso
+      );
+    } else if (!Array.isArray(points) || points.length === 0) {
+      adapter.setActivityField(childId, COLUMN.PONDERATOR, 0);
+    }
+  }
+}
+function criterionValue(childId, criterion, adapter) {
+  const child = adapter.getActivity(childId);
+  if (!child) return 0;
+  const active = getActiveBaseline(child);
+  if (!active) return 0;
+  if (criterion === "COST") return toNumber(active.cost);
+  if (criterion === "HH") return toNumber(active.workHours);
+  const type = child.type;
+  if (type === "project")
+    return sumRecursiveBaselineDurationDays(childId, adapter);
+  if (type === "milestone") return 0;
+  return toNumber(active.durationDays);
+}
+function sumRecursiveBaselineDurationDays(activityId, adapter) {
+  let sum = 0;
+  for (const childId of adapter.getChildren(activityId)) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    const active = getActiveBaseline(child);
+    if (!active) continue;
+    const type = child.type;
+    if (type === "project") {
+      sum += sumRecursiveBaselineDurationDays(String(childId), adapter);
+    } else if (type !== "milestone") {
+      sum += toNumber(active.durationDays);
+    }
+  }
+  return sum;
+}
+function toNumber(v) {
+  const n = typeof v === "string" ? parseFloat(v) : v;
+  return typeof n === "number" && Number.isFinite(n) ? n : 0;
+}
+
+// src/propagations/downward/recompute-all-ponderators.ts
+function recomputeAllPonderators(criterion, adapter) {
+  adapter.forEachActivity((_a, id) => {
+    adapter.setActivityField(id, COLUMN.PONDERATOR, 0);
+  });
+  adapter.forEachActivity((_a, id) => {
+    if (adapter.getChildren(id).length > 0) {
+      recomputePonderatorsForParent(String(id), criterion, adapter);
+    }
+  });
+}
+
+// src/propagations/upward/progress-rollup.ts
+function recomputeAllProgressRollup(adapter) {
+  for (const parentId of parentsDeepestFirst(adapter)) {
+    rollupParent(parentId, adapter);
+  }
+}
+function parentsDeepestFirst(adapter) {
+  const parents = /* @__PURE__ */ new Set();
+  adapter.forEachActivity((_activity, id) => {
+    if (adapter.getChildren(id).length > 0) parents.add(id);
+  });
+  const depthById = /* @__PURE__ */ new Map();
+  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
+  return [...parents].sort(
+    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
+  );
+}
+function depthOf2(id, adapter) {
+  let depth = 0;
+  let current = id;
+  while (current && current !== "0") {
+    if (!adapter.getActivity(current)) break;
+    depth += 1;
+    current = adapter.getParentId(current);
+  }
+  return depth;
+}
+function rollupParent(parentId, adapter) {
+  const childIds = adapter.getChildren(parentId);
+  if (childIds.length === 0) return;
+  const children = [];
+  for (const childId of childIds) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    children.push({
+      progress: Number(child.progress ?? 0),
+      ponderator: Number(child.ponderator ?? 0)
+    });
+  }
+  const rollup = computeWeightedProgressRollup(children);
+  if (rollup !== null) {
+    adapter.setActivityField(
+      parentId,
+      COLUMN.PROGRESS,
+      roundProgressPerLevel(rollup)
+    );
+  }
+}
+
+// src/dispatch/shared/baseline-weighted-fields.ts
+function recomputeBaselineWeightedFields(deps, criterion) {
+  recomputeAllPonderators(criterion, deps.adapter);
+  recomputeAllProgressRollup(deps.adapter);
+  if (deps.now) {
+    runExpectedProgressBase(
+      deps.adapter,
+      deps.now,
+      deps.defaultBaseCalendarId ?? null
+    );
+    applyExpectedProgressLive(deps.adapter, deps.now);
+  }
+  emitRealCost(deps.adapter);
+  if (deps.now) applyStatusPass(deps.adapter, deps.sector.statusCriteria);
+}
+
+// src/dispatch/handlers/baseline-apply.ts
+function activeBaselineSignature(deps) {
+  return JSON.stringify(
+    deps.adapter.getAllIds().map((id) => {
+      const point = deps.adapter.getActivity(id)?.baselinePoints.find((candidate) => candidate.isActiveVersion);
+      return point ? [
+        String(id),
+        point.versionId,
+        point.startDate?.getTime() ?? null,
+        point.endDate?.getTime() ?? null,
+        point.durationDays,
+        point.cost,
+        point.workHours,
+        point.baseCalendarId,
+        point.hoursPerDay,
+        point.hoursPerWeek
+      ] : [String(id), null];
+    })
+  );
+}
+function dispatchBaselineApply(action, deps) {
+  const beforeSnap = snapshotActivities(
+    deps.adapter,
+    new Set(deps.adapter.getAllIds())
+  );
+  const activeBaselineBefore = activeBaselineSignature(deps);
+  const changedIds = applyBaselineOverlay(
+    deps.adapter,
+    action.points,
+    deps.now,
+    deps.reporter,
+    deps.defaultBaseCalendarId ?? null
+  );
+  if (activeBaselineSignature(deps) !== activeBaselineBefore) {
+    recomputeBaselineWeightedFields(
+      deps,
+      deps.sector.activityCreter ?? "DURATION"
+    );
+  }
+  return {
+    ok: true,
+    changes: assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: changedIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/ponderator-criterion-set.ts
+function assertValidCriterion(value) {
+  if (value === "DURATION" || value === "COST" || value === "HH") return;
+  throw new Error(
+    `ponderator-criterion-set: invalid criterion "${String(value)}"`
+  );
+}
+function dispatchPonderatorCriterionSet(action, deps) {
+  assertValidCriterion(action.criterion);
+  const allIds = new Set(deps.adapter.getAllIds());
+  const beforeSnap = snapshotActivities(deps.adapter, allIds);
+  recomputeBaselineWeightedFields(deps, action.criterion);
+  deps.sector.activityCreter = action.criterion;
+  return {
+    ok: true,
+    changes: assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: allIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/status-criteria-set.ts
+function dispatchStatusCriteriaSet(action, deps) {
+  const resolved = resolveStatusCriteria(action.criteria);
+  const allIds = new Set(deps.adapter.getAllIds());
+  const beforeSnap = snapshotActivities(deps.adapter, allIds);
+  const changedIds = applyStatusPass(deps.adapter, resolved);
+  deps.sector.statusCriteria = resolved;
+  return {
+    ok: true,
+    changes: assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: changedIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
 // src/dispatch/dispatch.ts
 async function dispatch(action, options, deps) {
+  if (action.kind === "persistence-acknowledge") {
+    return dispatchPersistenceAcknowledge(action, deps);
+  }
+  if (action.kind === "baseline-apply") {
+    return dispatchBaselineApply(action, deps);
+  }
+  if (action.kind === "ponderator-criterion-set") {
+    return dispatchPonderatorCriterionSet(action, deps);
+  }
+  if (action.kind === "status-criteria-set") {
+    return dispatchStatusCriteriaSet(action, deps);
+  }
   if (action.kind === "link-create" || action.kind === "link-update" || action.kind === "link-delete") {
     return dispatchLink(action, options, deps);
   }
@@ -15515,8 +16161,15 @@ var WriteCapture = class {
   /** Pre-applyResults clone of an activity the autoscheduler will move (first-wins). */
   noteScheduledBefore(activityId, current) {
     const journal = this._journal;
-    if (!journal || journal.scheduledBefore.has(activityId)) return;
-    journal.scheduledBefore.set(activityId, cloneCoreActivity(current));
+    if (!journal) return;
+    const beforeImage = cloneCoreActivity(current);
+    if (!journal.scheduledBefore.has(activityId)) {
+      journal.scheduledBefore.set(activityId, beforeImage);
+    }
+    if (!journal.before.has(activityId)) {
+      journal.before.set(activityId, beforeImage);
+    }
+    journal.dirty.add(activityId);
   }
   /** Field write on a link — pre-mutation clone on first write per link id. */
   noteLinkField(linkId, current) {
@@ -15530,20 +16183,6 @@ var WriteCapture = class {
     });
   }
 };
-function cloneCoreActivity(activity) {
-  return {
-    ...activity,
-    startDate: new Date(activity.startDate),
-    endDate: new Date(activity.endDate),
-    constraintDate: activity.constraintDate ? new Date(activity.constraintDate) : null,
-    dateOrigin: activity.dateOrigin ? new Date(activity.dateOrigin) : null,
-    newActivityIds: [...activity.newActivityIds],
-    pendingRequestIds: [...activity.pendingRequestIds],
-    responsableIds: [...activity.responsableIds],
-    tagIds: [...activity.tagIds],
-    baselinePoints: [...activity.baselinePoints]
-  };
-}
 function cloneLink(link) {
   return { ...link };
 }
@@ -15723,6 +16362,18 @@ var HierarchyIndex = class {
       arr.push(activity.id);
       this._childrenByParent.set(key, arr);
     }
+    const compareIds = (left, right) => {
+      const leftActivity = this.activities.get(left);
+      const rightActivity = this.activities.get(right);
+      if (!(leftActivity && rightActivity)) {
+        return String(left).localeCompare(String(right));
+      }
+      return compareActivitiesInVisualOrder(leftActivity, rightActivity);
+    };
+    this._roots.sort(compareIds);
+    for (const children of this._childrenByParent.values()) {
+      children.sort(compareIds);
+    }
   }
 };
 
@@ -15785,6 +16436,13 @@ var ScheduleState = class {
   // whether a soft constraint repositioned the activity. Never persisted,
   // never in the ChangeSet — not domain data on CoreActivity.
   _lastStartDate = /* @__PURE__ */ new Map();
+  // Transient gesture state: what a leaf looked like right before it gained its
+  // first child and became a summary. Read by the demotion to give the activity
+  // its own values back instead of the aggregate its children left behind. Not
+  // persisted and not in the ChangeSet: it only makes sense inside the session
+  // that performed the promotion. Kept (not consumed) so undo/redo of a
+  // demotion restores identically every time.
+  _promotionSnapshot = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
@@ -15800,6 +16458,7 @@ var ScheduleState = class {
   _viewState = new ViewStateStore();
   _viewStateBefore = null;
   _lastStartDateBefore = null;
+  _promotionSnapshotBefore = null;
   // Calendar arithmetic + in-dispatch memoization. Assigned in the
   // constructor once the calendar reader is built. See `CalendarCalculator`.
   _calendar;
@@ -15884,6 +16543,19 @@ var ScheduleState = class {
     this._captureLastStartDateOnce();
     this._lastStartDate.set(String(activityId), startDate);
   }
+  getPromotionSnapshot(activityId) {
+    return this._promotionSnapshot.get(String(activityId)) ?? null;
+  }
+  setPromotionSnapshot(activityId, snapshot) {
+    this._capturePromotionSnapshotOnce();
+    this._promotionSnapshot.set(String(activityId), snapshot);
+  }
+  _capturePromotionSnapshotOnce() {
+    if (this._writeCapture.peek() === null) return;
+    if (this._promotionSnapshotBefore === null) {
+      this._promotionSnapshotBefore = new Map(this._promotionSnapshot);
+    }
+  }
   _captureLastStartDateOnce() {
     if (this._writeCapture.peek() === null) return;
     if (this._lastStartDateBefore === null) {
@@ -16000,6 +16672,7 @@ var ScheduleState = class {
     this._writeCapture.begin();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
+    this._promotionSnapshotBefore = null;
   }
   /** The live journal, or null when no capture is active. */
   peekWriteCapture() {
@@ -16010,6 +16683,7 @@ var ScheduleState = class {
     this._writeCapture.end();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
+    this._promotionSnapshotBefore = null;
   }
   // -- Replay-specific mutators --------------------------------------------
   setActivityField(activityId, field, value) {
@@ -16161,439 +16835,156 @@ var ScheduleState = class {
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
     }
+    if (this._promotionSnapshotBefore !== null) {
+      this._promotionSnapshot = this._promotionSnapshotBefore;
+    }
     if (this._lastStartDateBefore !== null) {
       this._lastStartDate = this._lastStartDateBefore;
     }
     this._cache.ids = null;
-    this._cache.visualOrderIds = null;
-    this._hierarchy.markDirty();
-  }
-  _restoreCorrelatives(correlativeBefore) {
-    for (const [id, before] of correlativeBefore) {
-      const live = this._activities.get(id);
-      if (live) live.correlativeId = before;
-    }
-  }
-  _undoLinkAdds(ops) {
-    for (const op of ops)
-      if (op.kind === "link-add") this._detachLink(op.linkId);
-  }
-  _undoInserts(ops) {
-    for (const op of ops)
-      if (op.kind === "insert") this._activities.delete(op.activityId);
-  }
-  _reInsertRemovedActivities(ops) {
-    for (const op of ops)
-      if (op.kind === "remove") this._activities.set(op.activityId, op.before);
-  }
-  _reAddRemovedLinks(ops) {
-    for (const op of ops)
-      if (op.kind === "link-remove") this._attachLink(op.before);
-  }
-  _restoreLinkFields(ops) {
-    for (const op of ops)
-      if (op.kind === "link-field" && this._links.has(op.linkId))
-        this._links.set(op.linkId, op.before);
-  }
-  _restoreActivityFields(before) {
-    for (const [id, snapshot] of before) {
-      const live = this._activities.get(id);
-      if (live) this._restoreScalarFields(live, snapshot);
-    }
-  }
-  _restoreScalarFields(live, before) {
-    for (const key of Object.keys(live)) {
-      if (!Object.hasOwn(before, key)) Reflect.deleteProperty(live, key);
-    }
-    for (const key of Object.keys(before)) {
-      Reflect.set(live, key, Reflect.get(before, key));
-    }
-  }
-  _attachLink(link) {
-    this._links.set(String(link.id), { ...link });
-    this._indexLink(link);
-  }
-  _detachLink(linkId) {
-    const link = this.getLink(linkId);
-    if (!link) return;
-    this._links.delete(String(linkId));
-    this._deindexLink(link);
-  }
-};
-var EMPTY_LINK_IDS = [];
-function isMutableLinkField(field) {
-  return field === LINK_PROPERTY.LAG || field === LINK_PROPERTY.TYPE;
-}
-function fieldAffectsVisualOrder(field) {
-  return field === ACTIVITY_PROPERTY.PARENT || field === ACTIVITY_PROPERTY.CORRELATIVE_ID;
-}
-function detachLinkRef(refs, linkId) {
-  return refs.filter((ref) => String(ref) !== String(linkId));
-}
-function pushLinkRef(map, key, linkId) {
-  const refs = map.get(key);
-  if (refs) refs.push(linkId);
-  else map.set(key, [linkId]);
-}
-function buildFlags(snapshot) {
-  const rawFlags = snapshot.runtimeFlags ?? {};
-  return {
-    isPasting: Boolean(rawFlags.isPasting),
-    isBulkOperation: Boolean(rawFlags.isBulkOperation),
-    dragWithMultiple: Boolean(rawFlags.dragWithMultiple),
-    draggingSingleMilestone: Boolean(rawFlags.draggingSingleMilestone),
-    creatingActivity: false,
-    avoidAutoScheduleBeforeDrag: false,
-    maxPerformance: Boolean(rawFlags.maxPerformance),
-    allCheckedTaskIds: []
-  };
-}
-
-// src/init/read-api.ts
-function readActivity(state, id) {
-  return state.getActivity(id);
-}
-function readAllActivities(state) {
-  return state.getAllActivities();
-}
-function readAllIds(state) {
-  return state.getAllIds().map(String);
-}
-function forEachActivityId(state, visit) {
-  state.forEachActivity((_activity, id) => visit(id));
-}
-function readChildren(state, parentId) {
-  const childIds = parentId === ROOT_PARENT_ID ? readChildrenIds(state, ROOT_PARENT_ID) : state.getChildren(parentId);
-  const out = [];
-  for (const id of childIds) {
-    const snap = state.getActivity(id);
-    if (snap) out.push(snap);
-  }
-  out.sort((a, b) => (a.correlativeId ?? 0) - (b.correlativeId ?? 0));
-  return out;
-}
-function readChildrenIds(state, parentId) {
-  const key = parentId;
-  if (key === ROOT_PARENT_ID) {
-    const roots = [];
-    state.forEachActivity((activity, id) => {
-      if (isRootParent(activity.parentId)) roots.push(id);
-    });
-    return roots;
-  }
-  return [...state.getChildren(key)].map(String);
-}
-function readSelectedActivityIds(state) {
-  return state.checkedIds().map(String);
-}
-function readHasChild(state, parentId) {
-  return state.getChildren(parentId).length > 0;
-}
-function readLink(state, id) {
-  const l = state.getLink(id);
-  return l ? snapshotToLink(l) : null;
-}
-function readAllLinks(state) {
-  return state.getAllLinks().map((l) => snapshotToLink(l));
-}
-
-// src/propagations/downward/recompute-ponderator-for-parent.ts
-function recomputePonderatorsForParent(parentId, criterion, adapter) {
-  if (!parentId || parentId === "0") return;
-  const childIds = adapter.getChildren(parentId);
-  if (childIds.length === 0) return;
-  const pesoById = /* @__PURE__ */ new Map();
-  let denominator = 0;
-  for (const childId of childIds) {
-    const peso = criterionValue(String(childId), criterion, adapter);
-    pesoById.set(String(childId), peso);
-    denominator += peso;
-  }
-  const relationValue = denominator ? 100 / denominator : 0;
-  for (const childId of childIds) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    const points = child.baselinePoints;
-    const active = getActiveBaseline(child);
-    if (active) {
-      const peso = pesoById.get(String(childId)) ?? 0;
-      adapter.setActivityField(
-        childId,
-        COLUMN.PONDERATOR,
-        relationValue * peso
-      );
-    } else if (!Array.isArray(points) || points.length === 0) {
-      adapter.setActivityField(childId, COLUMN.PONDERATOR, 0);
-    }
-  }
-}
-function criterionValue(childId, criterion, adapter) {
-  const child = adapter.getActivity(childId);
-  if (!child) return 0;
-  const active = getActiveBaseline(child);
-  if (!active) return 0;
-  if (criterion === "COST") return toNumber(active.cost);
-  if (criterion === "HH") return toNumber(active.workHours);
-  const type = child.type;
-  if (type === "project")
-    return sumRecursiveBaselineDurationDays(childId, adapter);
-  if (type === "milestone") return 0;
-  return toNumber(active.durationDays);
-}
-function sumRecursiveBaselineDurationDays(activityId, adapter) {
-  let sum = 0;
-  for (const childId of adapter.getChildren(activityId)) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    const active = getActiveBaseline(child);
-    if (!active) continue;
-    const type = child.type;
-    if (type === "project") {
-      sum += sumRecursiveBaselineDurationDays(String(childId), adapter);
-    } else if (type !== "milestone") {
-      sum += toNumber(active.durationDays);
-    }
-  }
-  return sum;
-}
-function toNumber(v) {
-  const n = typeof v === "string" ? parseFloat(v) : v;
-  return typeof n === "number" && Number.isFinite(n) ? n : 0;
-}
-
-// src/propagations/downward/recompute-all-ponderators.ts
-function recomputeAllPonderators(criterion, adapter) {
-  adapter.forEachActivity((_a, id) => {
-    adapter.setActivityField(id, COLUMN.PONDERATOR, 0);
-  });
-  adapter.forEachActivity((_a, id) => {
-    if (adapter.getChildren(id).length > 0) {
-      recomputePonderatorsForParent(String(id), criterion, adapter);
+    this._cache.visualOrderIds = null;
+    this._hierarchy.markDirty();
+  }
+  _restoreCorrelatives(correlativeBefore) {
+    for (const [id, before] of correlativeBefore) {
+      const live = this._activities.get(id);
+      if (live) live.correlativeId = before;
     }
-  });
-}
-
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
   }
-}
-function parentsDeepestFirst(adapter) {
-  const parents = /* @__PURE__ */ new Set();
-  adapter.forEachActivity((_activity, id) => {
-    if (adapter.getChildren(id).length > 0) parents.add(id);
-  });
-  const depthById = /* @__PURE__ */ new Map();
-  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
-  return [...parents].sort(
-    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
-  );
-}
-function depthOf2(id, adapter) {
-  let depth = 0;
-  let current = id;
-  while (current && current !== "0") {
-    if (!adapter.getActivity(current)) break;
-    depth += 1;
-    current = adapter.getParentId(current);
+  _undoLinkAdds(ops) {
+    for (const op of ops)
+      if (op.kind === "link-add") this._detachLink(op.linkId);
   }
-  return depth;
-}
-function rollupParent(parentId, adapter) {
-  const childIds = adapter.getChildren(parentId);
-  if (childIds.length === 0) return;
-  const children = [];
-  for (const childId of childIds) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    children.push({
-      progress: Number(child.progress ?? 0),
-      ponderator: Number(child.ponderator ?? 0)
-    });
+  _undoInserts(ops) {
+    for (const op of ops)
+      if (op.kind === "insert") this._activities.delete(op.activityId);
   }
-  const rollup = computeWeightedProgressRollup(children);
-  if (rollup !== null) {
-    adapter.setActivityField(
-      parentId,
-      COLUMN.PROGRESS,
-      roundProgressPerLevel(rollup)
-    );
+  _reInsertRemovedActivities(ops) {
+    for (const op of ops)
+      if (op.kind === "remove") this._activities.set(op.activityId, op.before);
   }
-}
-
-// src/baselines/normalize-baseline-point.ts
-function parseBaselineDate(value) {
-  return typeof value === "string" && value.length > 0 ? parseBackendDate(value) : value instanceof Date ? value : null;
-}
-function parseFiniteNonNegative(value) {
-  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
-  if (!Number.isFinite(numeric) || numeric < 0) return null;
-  return numeric;
-}
-function normalizeBaselinePoint(point, reporter) {
-  const durationDays = parseFiniteNonNegative(point.duration);
-  const cost = parseFiniteNonNegative(point.cost);
-  const workHours = parseFiniteNonNegative(point.hh_work);
-  if (durationDays === null || cost === null || workHours === null) {
-    reporter.warn(
-      `[baseline] dropping point with non-finite/negative magnitude \u2014 duration=${JSON.stringify(point.duration)}, cost=${JSON.stringify(point.cost)}, hh_work=${JSON.stringify(point.hh_work)}`
-    );
-    return null;
+  _reAddRemovedLinks(ops) {
+    for (const op of ops)
+      if (op.kind === "link-remove") this._attachLink(op.before);
   }
-  return {
-    startDate: parseBaselineDate(point.start_date),
-    endDate: parseBaselineDate(point.end_date),
-    durationDays,
-    cost,
-    workHours,
-    versionId: typeof point.sectorbaselineversionId === "number" ? point.sectorbaselineversionId : null,
-    isActiveVersion: Boolean(point.sectorbaselineversion?.active),
-    baseCalendarId: point.baseCalendarId != null ? String(point.baseCalendarId) : null,
-    hoursPerDay: typeof point.hoursPerDay === "number" ? point.hoursPerDay : null,
-    hoursPerWeek: typeof point.hoursPerWeek === "number" ? point.hoursPerWeek : null
-  };
-}
-
-// src/baselines/apply-baseline-points.ts
-function applyBaselinePoints(adapter, points, reporter) {
-  const idByProplanner = /* @__PURE__ */ new Map();
-  adapter.forEachActivity((a, id) => {
-    const pid = a.proplannerId;
-    if (typeof pid === "number") idByProplanner.set(pid, id);
-  });
-  const grouped = /* @__PURE__ */ new Map();
-  for (const p of points) {
-    const activityId = p.activityId;
-    if (typeof activityId !== "number") continue;
-    const coreId = idByProplanner.get(activityId);
-    if (coreId === void 0) continue;
-    const arr = grouped.get(coreId);
-    if (arr) arr.push(p);
-    else grouped.set(coreId, [p]);
+  _restoreLinkFields(ops) {
+    for (const op of ops)
+      if (op.kind === "link-field" && this._links.has(op.linkId))
+        this._links.set(op.linkId, op.before);
   }
-  const changed = [];
-  for (const [coreId, group] of grouped) {
-    adapter.setActivityField(
-      coreId,
-      "baselinePoints",
-      group.map((point) => normalizeBaselinePoint(point, reporter)).filter((point) => point !== null)
-    );
-    changed.push(coreId);
+  _restoreActivityFields(before) {
+    for (const [id, snapshot] of before) {
+      const live = this._activities.get(id);
+      if (live) this._restoreScalarFields(live, snapshot);
+    }
   }
-  adapter.forEachActivity((a, id) => {
-    if (grouped.has(id)) return;
-    const existing = a.baselinePoints;
-    if (Array.isArray(existing) && existing.length > 0) {
-      adapter.setActivityField(id, "baselinePoints", []);
-      changed.push(id);
+  _restoreScalarFields(live, before) {
+    for (const key of Object.keys(live)) {
+      if (!Object.hasOwn(before, key)) Reflect.deleteProperty(live, key);
     }
-  });
-  return changed;
+    for (const key of Object.keys(before)) {
+      Reflect.set(live, key, Reflect.get(before, key));
+    }
+  }
+  _attachLink(link) {
+    this._links.set(String(link.id), { ...link });
+    this._indexLink(link);
+  }
+  _detachLink(linkId) {
+    const link = this.getLink(linkId);
+    if (!link) return;
+    this._links.delete(String(linkId));
+    this._deindexLink(link);
+  }
+};
+var EMPTY_LINK_IDS = [];
+function isMutableLinkField(field) {
+  return field === LINK_PROPERTY.LAG || field === LINK_PROPERTY.TYPE;
 }
-
-// src/baselines/baseline-snapshot.ts
-function buildBaselineSnapshot(activity) {
-  const active = getActiveBaseline(activity);
-  if (!active) return null;
+function fieldAffectsVisualOrder(field) {
+  return field === ACTIVITY_PROPERTY.PARENT || field === ACTIVITY_PROPERTY.CORRELATIVE_ID;
+}
+function detachLinkRef(refs, linkId) {
+  return refs.filter((ref) => String(ref) !== String(linkId));
+}
+function pushLinkRef(map, key, linkId) {
+  const refs = map.get(key);
+  if (refs) refs.push(linkId);
+  else map.set(key, [linkId]);
+}
+function buildFlags(snapshot) {
+  const rawFlags = snapshot.runtimeFlags ?? {};
   return {
-    startDate: active.startDate,
-    endDate: active.endDate,
-    durationDays: active.durationDays,
-    cost: active.cost,
-    workHours: active.workHours
+    isPasting: Boolean(rawFlags.isPasting),
+    isBulkOperation: Boolean(rawFlags.isBulkOperation),
+    dragWithMultiple: Boolean(rawFlags.dragWithMultiple),
+    draggingSingleMilestone: Boolean(rawFlags.draggingSingleMilestone),
+    creatingActivity: false,
+    avoidAutoScheduleBeforeDrag: false,
+    maxPerformance: Boolean(rawFlags.maxPerformance),
+    allCheckedTaskIds: []
   };
 }
-function emitBaselineSnapshotColumns(state) {
-  const changed = [];
-  state.forEachActivity((activity, id) => {
-    const snapshot = buildBaselineSnapshot(activity);
-    if (!snapshot) return;
-    state.setActivityField(id, "baselineSnapshot", snapshot);
-    changed.push(id);
-  });
-  return changed;
-}
 
-// src/baselines/apply-baseline-overlay.ts
-function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarId = null) {
-  if (points.length === 0) return [];
-  const changed = /* @__PURE__ */ new Set();
-  for (const id of applyBaselinePoints(
-    state,
-    points,
-    reporter
-  )) {
-    changed.add(id);
-  }
-  if (now) {
-    for (const id of runExpectedProgressBase(state, now, defaultBaseCalendarId))
-      changed.add(id);
-  }
-  for (const id of emitBaselineSnapshotColumns(state)) changed.add(id);
-  for (const id of emitRealCost(state)) changed.add(id);
-  return [...changed];
+// src/shared/clone-domain-value.ts
+function cloneDomainValue(value) {
+  return structuredClone(value);
 }
 
-// src/init/recompute-api.ts
-function readPonderator(a) {
-  const v = a.ponderator;
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+// src/init/read-api.ts
+function readActivity(state, id) {
+  const activity = state.getActivity(id);
+  return activity ? cloneDomainValue(activity) : null;
 }
-function readProgress(a) {
-  const v = a.progress;
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+function readAllActivities(state) {
+  return state.getAllActivities().map(cloneDomainValue);
 }
-function recomputeAllPonderators2(state, _hoursPerDay, criterion) {
-  const before = /* @__PURE__ */ new Map();
-  state.forEachActivity((a, id) => {
-    before.set(id, readPonderator(a));
-  });
-  recomputeAllPonderators(criterion, state);
-  const changed = [];
-  state.forEachActivity((a, id) => {
-    if (readPonderator(a) !== (before.get(id) ?? 0)) {
-      changed.push(structuredCloneActivity(a));
-    }
-  });
-  return changed;
+function readAllIds(state) {
+  return state.getAllIds().map(String);
 }
-function recomputeAllProgressRollup2(state, _hoursPerDay) {
-  const before = /* @__PURE__ */ new Map();
-  state.forEachActivity((a, id) => {
-    before.set(id, readProgress(a));
-  });
-  recomputeAllProgressRollup(state);
-  const changed = [];
-  state.forEachActivity((a, id) => {
-    if (readProgress(a) !== (before.get(id) ?? 0)) {
-      changed.push(structuredCloneActivity(a));
-    }
-  });
-  return changed;
+function forEachActivityId(state, visit) {
+  state.forEachActivity((_activity, id) => visit(id));
 }
-function applyBaselines(state, _hoursPerDay, points, now, reporter, defaultBaseCalendarId = null) {
-  const changedIds = applyBaselineOverlay(
-    state,
-    points,
-    now,
-    reporter,
-    defaultBaseCalendarId
-  );
-  const changed = [];
-  for (const id of changedIds) {
+function readChildren(state, parentId) {
+  const childIds = parentId === ROOT_PARENT_ID ? readChildrenIds(state, ROOT_PARENT_ID) : state.getChildren(parentId);
+  const out = [];
+  for (const id of childIds) {
     const snap = state.getActivity(id);
-    if (snap) changed.push(structuredCloneActivity(snap));
+    if (snap) out.push(cloneDomainValue(snap));
+  }
+  out.sort((a, b) => (a.correlativeId ?? 0) - (b.correlativeId ?? 0));
+  return out;
+}
+function readChildrenIds(state, parentId) {
+  const key = parentId;
+  if (key === ROOT_PARENT_ID) {
+    const roots = [];
+    state.forEachActivity((activity, id) => {
+      if (isRootParent(activity.parentId)) roots.push(id);
+    });
+    return roots;
   }
-  return changed;
+  return [...state.getChildren(key)].map(String);
 }
-function recomputeStatus(state, _hoursPerDay, criteria) {
-  const changed = [];
-  for (const id of applyStatusPass(state, criteria)) {
-    const snap = state.getActivity(id);
-    if (snap) changed.push(structuredCloneActivity(snap));
+function readSelectedActivityIds(state) {
+  return state.checkedIds().map(String);
+}
+function readHasChild(state, parentId) {
+  if (parentId === ROOT_PARENT_ID) {
+    let hasRoot = false;
+    state.forEachActivity((activity) => {
+      hasRoot ||= isRootParent(activity.parentId);
+    });
+    return hasRoot;
   }
-  return changed;
+  return state.getChildren(parentId).length > 0;
+}
+function readLink(state, id) {
+  const l = state.getLink(id);
+  return l ? snapshotToLink(l) : null;
+}
+function readAllLinks(state) {
+  return state.getAllLinks().map((l) => snapshotToLink(l));
 }
 
 // src/internal/state/project-work-hours.ts
@@ -16703,8 +17094,12 @@ function mergeCoalesced(top, next) {
   };
   return buildUndoEntry(changeSet);
 }
-function isUndoableAction(action) {
-  return action.kind !== "sir-sync" && action.kind !== "activity-lookahead-sync";
+function getDispatchHistoryPolicy(action) {
+  if (action.kind === "persistence-acknowledge") return "clear-on-success";
+  if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set") {
+    return "skip";
+  }
+  return "record";
 }
 function needsResync(entry) {
   for (const change of entry.changeSet.activities) {
@@ -16724,6 +17119,7 @@ function buildInverseChangeSet(state, entry, side) {
       activities.push({
         id: activityId,
         kind: "updated",
+        fields: historyFields(change.fields, side),
         after: snapshot ? structuredCloneActivity(snapshot) : null
       });
     } else if (change.kind === "deleted") {
@@ -16757,6 +17153,7 @@ function buildInverseChangeSet(state, entry, side) {
       links.push({
         id: linkId,
         kind: "updated",
+        fields: historyFields(change.fields, side),
         after: lk ? snapshotToLink(lk) : null
       });
     } else if (change.kind === "deleted") {
@@ -16796,6 +17193,21 @@ function buildInverseChangeSet(state, entry, side) {
     viewState
   };
 }
+function historyFields(fields, side) {
+  if (fields == null) return void 0;
+  return Object.fromEntries(
+    Object.entries(fields).map(([field, values]) => [
+      field,
+      side === "before" ? {
+        before: cloneDomainValue(values.after),
+        after: cloneDomainValue(values.before)
+      } : {
+        before: cloneDomainValue(values.before),
+        after: cloneDomainValue(values.after)
+      }
+    ])
+  );
+}
 function invertViewStateChange(change) {
   return {
     activityId: change.activityId,
@@ -16971,6 +17383,7 @@ var UndoRecorder = class {
   clear() {
     this.undoStack.length = 0;
     this.redoStack.length = 0;
+    this.resetCoalesce();
   }
 };
 
@@ -17333,8 +17746,7 @@ function parseActivity(raw, context) {
     expectedProgress: null,
     expectedProgressBaseline: null,
     status: null,
-    criticalPath: null,
-    promotionRestore: null
+    criticalPath: null
   };
 }
 function forceRootProjectToRoot(activities) {
@@ -18339,6 +18751,117 @@ function snapDemotedLeafTiming(state, activityId) {
   state.setActivityField(activityId, ACTIVITY_PROPERTY.END_DATE, end);
 }
 
+// src/propagations/upward/recompute-real-work.ts
+function recomputeCanonicalRealWork(state) {
+  const rootIds = [];
+  const changedIds = [];
+  state.forEachActivity((activity, activityId) => {
+    if (activity.parentId === null) rootIds.push(String(activityId));
+  });
+  const visit = (activityId) => {
+    const activity = state.getActivity(activityId);
+    if (!activity) return 0;
+    const childIds = [...state.getChildren(activityId)];
+    const realWork = childIds.length === 0 ? computeLeafRealWork(activity.workHours, activity.progress) : childIds.reduce(
+      (total, childId) => total + visit(String(childId)),
+      0
+    );
+    state.setActivityField(
+      activityId,
+      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
+      realWork
+    );
+    changedIds.push(activityId);
+    return realWork;
+  };
+  for (const rootId of rootIds) visit(rootId);
+  return changedIds;
+}
+
+// src/init/initial-passes.ts
+async function runInitialPasses(deps) {
+  const { state, sector, scheduler, skipAutoSchedule, now } = deps;
+  recomputeCorrelativeIds(state);
+  if (sector.updateDurationForPrimaveraEndDate) {
+    recomputeDurationsFromDates(state);
+  }
+  normalizeLoadedConstraintDates(state);
+  recomputeCanonicalRealWork(state);
+  if (skipAutoSchedule) {
+    if (now) {
+      applyExpectedProgressLive(state, now);
+      applyStatusPass(state, sector.statusCriteria);
+    }
+    return;
+  }
+  const result = await scheduler.schedule({});
+  applyResults(state, result);
+  normalizeMilestoneConstraintDatesForDisplay(state);
+  recomputeSkippedLeafEnds(state);
+  await updateParentBoundsFromChildren(state, void 0, false);
+  if (now) {
+    applyExpectedProgressLive(state, now);
+    applyStatusPass(state, sector.statusCriteria);
+  }
+}
+function recomputeSkippedLeafEnds(state) {
+  state.forEachActivity((activity) => {
+    if (activity.autoScheduling) return;
+    if (!activity.startDate || activity.durationHours == null) return;
+    if (state.getChildren(activity.id).length > 0) return;
+    activity.endDate = state.calculateEndDate({
+      startDate: activity.startDate,
+      durationHours: activity.durationHours,
+      task: activity
+    });
+  });
+}
+function recomputeDurationsFromDates(state) {
+  state.forEachActivity((activity) => {
+    if (!activity.startDate || !activity.endDate) return;
+    activity.durationHours = state.calculateDuration({
+      startDate: activity.startDate,
+      endDate: activity.endDate,
+      task: activity
+    });
+  });
+}
+function normalizeLoadedConstraintDates(state) {
+  state.forEachActivity((activity) => {
+    const type = activity.constraintType;
+    if (!type || !activity.constraintDate) return;
+    const constraintDate = activity.constraintDate;
+    if (activity.type === "milestone" && (constraintDate.getUTCHours() !== 0 || constraintDate.getUTCMinutes() !== 0)) {
+      return;
+    }
+    const calendar = state.calendarReader.getCalendar(
+      String(activity.calendarId)
+    );
+    if (!calendar) return;
+    activity.constraintDate = normalizeConstraintDate(
+      activity.constraintDate,
+      calendar,
+      type
+    );
+  });
+}
+function normalizeMilestoneConstraintDatesForDisplay(state) {
+  state.forEachActivity((activity) => {
+    if (activity.type !== "milestone") return;
+    const type = activity.constraintType;
+    if (!type || !activity.constraintDate) return;
+    const calendar = state.calendarReader.getCalendar(
+      String(activity.calendarId)
+    );
+    if (!calendar) return;
+    activity.constraintDate = normalizeConstraintDate(
+      activity.constraintDate,
+      calendar,
+      type
+    );
+  });
+}
+
 // src/init/initialize-core.ts
 var SCHEDULE_CORE_STATUS = {
   READY: "ready",
@@ -18426,48 +18949,8 @@ function initializeCore(input) {
 }
 
 // src/init/schedule-core.ts
-function assertValidPersistenceAssignments(assignments, entityName, readCurrent, ownerByBackendId) {
-  const seenIds = /* @__PURE__ */ new Set();
-  const seenBackendIds = /* @__PURE__ */ new Set();
-  for (const assignment of assignments) {
-    const id = String(assignment.id);
-    if (id.length === 0 || seenIds.has(id)) {
-      throw new Error(
-        `acknowledgePersistence: duplicate or empty ${entityName} id "${id}"`
-      );
-    }
-    if (!Number.isSafeInteger(assignment.proplannerId) || assignment.proplannerId <= 0 || seenBackendIds.has(assignment.proplannerId)) {
-      throw new Error(
-        `acknowledgePersistence: invalid or duplicate ${entityName} proplannerId ${String(assignment.proplannerId)}`
-      );
-    }
-    const state = readCurrent(id);
-    if (!state.exists) {
-      throw new Error(
-        `acknowledgePersistence: unknown ${entityName} id "${id}"`
-      );
-    }
-    if (state.current !== null && state.current !== assignment.proplannerId) {
-      throw new Error(
-        `acknowledgePersistence: ${entityName} "${id}" already has proplannerId ${String(state.current)}`
-      );
-    }
-    const existingOwner = ownerByBackendId.get(assignment.proplannerId);
-    if (existingOwner !== void 0 && existingOwner !== id) {
-      throw new Error(
-        `acknowledgePersistence: ${entityName} proplannerId ${String(assignment.proplannerId)} already belongs to "${existingOwner}"`
-      );
-    }
-    seenIds.add(id);
-    seenBackendIds.add(assignment.proplannerId);
-  }
-}
 var ScheduleCore = class {
   _status = SCHEDULE_CORE_STATUS.READY;
-  /** True while an async dispatch is suspended inside the write-capture window.
-   * A sync facade mutation running in that gap would corrupt the in-flight
-   * journal, so sync mutators refuse to run while it is set. */
-  _dispatchInFlight = false;
   coreRuntime;
   _undo = new UndoRecorder();
   _opQueue = Promise.resolve();
@@ -18518,7 +19001,7 @@ var ScheduleCore = class {
     return this._status;
   }
   getSector() {
-    return this.coreRuntime.sector;
+    return cloneDomainValue(this.coreRuntime.sector);
   }
   getActivityView(id) {
     this.assertReady();
@@ -18544,7 +19027,7 @@ var ScheduleCore = class {
     this.assertReady();
     const snapshot = this.coreRuntime.state.getActivity(activityId);
     if (!snapshot) return null;
-    return snapshot[property];
+    return cloneDomainValue(snapshot[property]);
   }
   getAllIds() {
     this.assertReady();
@@ -18571,7 +19054,7 @@ var ScheduleCore = class {
    */
   getVisualOrderIds() {
     this.assertReady();
-    return this.coreRuntime.state.getVisualOrderIds();
+    return [...this.coreRuntime.state.getVisualOrderIds()];
   }
   hasChild(parentId) {
     this.assertReady();
@@ -18579,15 +19062,21 @@ var ScheduleCore = class {
   }
   getCalendar(id) {
     this.assertReady();
-    return this.coreRuntime.calendars.get(id) ?? null;
+    const calendar = this.coreRuntime.calendars.get(id);
+    return calendar ? cloneDomainValue(calendar) : null;
   }
   getAllCalendars() {
     this.assertReady();
-    return Array.from(this.coreRuntime.calendars.values());
+    return Array.from(
+      this.coreRuntime.calendars.values(),
+      (calendar) => cloneDomainValue(calendar)
+    );
   }
   getBaseCalendars() {
     this.assertReady();
-    return this.coreRuntime.baseCalendars;
+    return this.coreRuntime.baseCalendars.map(
+      (calendar) => cloneDomainValue(calendar)
+    );
   }
   isCustomIdInUse(customId, currentCustomId = null) {
     this.assertReady();
@@ -18604,184 +19093,9 @@ var ScheduleCore = class {
     this.assertReady();
     return this._saveTracker.modifiedLinks(this.getAllLinksView());
   }
-  markLinksPersisted() {
-    this._saveTracker.snapshotLinks(this.getAllLinksView());
-  }
   getModifiedActivities() {
     this.assertReady();
-    return this._saveTracker.modifiedActivities(
-      this.coreRuntime.state.getAllActivities()
-    );
-  }
-  markActivitiesPersisted() {
-    this._saveTracker.snapshotActivities(
-      this.coreRuntime.state.getAllActivities()
-    );
-  }
-  /**
-   * Reconciles the backend identities returned by a successful schedule save.
-   *
-   * This is an application-boundary acknowledgement, not an editable schedule
-   * gesture: it does not autoschedule, recompute, emit an undo entry, or invent
-   * domain changes. Every assignment is validated before the first mutation so
-   * a malformed/partial response cannot leave the core half-reconciled. Once
-   * applied, the complete live graph becomes the new save-tracker baseline.
-   */
-  acknowledgePersistence(acknowledgement) {
-    this.assertReady();
-    const activities = acknowledgement.activities ?? [];
-    const links = acknowledgement.links ?? [];
-    const activityOwnerByBackendId = /* @__PURE__ */ new Map();
-    for (const activity of this.coreRuntime.state.getAllActivities()) {
-      if (activity.proplannerId != null) {
-        activityOwnerByBackendId.set(
-          activity.proplannerId,
-          String(activity.id)
-        );
-      }
-    }
-    const linkOwnerByBackendId = /* @__PURE__ */ new Map();
-    for (const link of this.coreRuntime.state.getAllLinks()) {
-      if (link.proplannerId != null) {
-        linkOwnerByBackendId.set(link.proplannerId, String(link.id));
-      }
-    }
-    assertValidPersistenceAssignments(
-      activities,
-      "activity",
-      (id) => {
-        const activity = this.coreRuntime.state.getActivity(id);
-        return {
-          exists: activity !== null,
-          current: activity?.proplannerId ?? null
-        };
-      },
-      activityOwnerByBackendId
-    );
-    assertValidPersistenceAssignments(
-      links,
-      "link",
-      (id) => {
-        const link = this.coreRuntime.state.getLink(id);
-        return {
-          exists: link !== null,
-          current: link?.proplannerId ?? null
-        };
-      },
-      linkOwnerByBackendId
-    );
-    this.coreRuntime.state.batchUpdate(() => {
-      for (const assignment of activities) {
-        this.coreRuntime.state.setActivityField(
-          assignment.id,
-          "proplannerId",
-          assignment.proplannerId
-        );
-      }
-      for (const assignment of links) {
-        this.coreRuntime.state.setLinkProplannerId(
-          assignment.id,
-          assignment.proplannerId
-        );
-      }
-    });
-    this.markActivitiesPersisted();
-    this.markLinksPersisted();
-  }
-  applyBaselines(points) {
-    this.assertReady();
-    const now = this.coreRuntime.clock ? endOfLocalDay(this.coreRuntime.clock()) : null;
-    const defaultBaseCalendarId = this.coreRuntime.baseCalendars.find((calendar) => calendar.baseDefault)?.id ?? null;
-    return applyBaselines(
-      this.coreRuntime.state,
-      this.coreRuntime.sector.hoursPerDay,
-      points,
-      now,
-      this.coreRuntime.reporter,
-      defaultBaseCalendarId
-    );
-  }
-  /**
-   * Whole-tree ponderator recompute (zeroes, then redistributes 100 within
-   * each parent from its children's active baselines, weighted by `criterion`).
-   * Returns the activities whose `ponderator` changed, for a prop-only repaint.
-   * The base rollup (`applyBaselines`) depends on fresh ponderators, so callers
-   * run this before it on a criterion change or baseline save.
-   */
-  recomputeAllPonderators(criterion) {
-    this.assertReady();
-    return recomputeAllPonderators2(
-      this.coreRuntime.state,
-      this.coreRuntime.sector.hoursPerDay,
-      criterion
-    );
-  }
-  /**
-   * Recompute the weighted-progress rollup of every parent, bottom-up.
-   * Returns the activities whose `progress` changed, for a prop-only repaint.
-   */
-  recomputeAllProgressRollup() {
-    this.assertReady();
-    return recomputeAllProgressRollup2(
-      this.coreRuntime.state,
-      this.coreRuntime.sector.hoursPerDay
-    );
-  }
-  /**
-   * Set the project's status criterion (the Baseline↔Actual toggle) and
-   * recompute every activity's `status` against it. Stores the criterion so
-   * future dispatches keep deriving status with it. Returns the activities
-   * whose `status` changed, for a prop-only repaint.
-   */
-  setStatusCriteria(criteria) {
-    this.assertReady();
-    const resolved = resolveStatusCriteria(criteria);
-    this.coreRuntime.sector.statusCriteria = resolved;
-    return recomputeStatus(
-      this.coreRuntime.state,
-      this.coreRuntime.sector.hoursPerDay,
-      resolved
-    );
-  }
-  allocateActivityId() {
-    this.assertReady();
-    return this.coreRuntime.activityIdGenerator.next();
-  }
-  createActivity(input) {
-    this.assertReady();
-    if (this._dispatchInFlight) {
-      throw new Error(
-        "[ScheduleCore] createActivity called during an in-flight dispatch"
-      );
-    }
-    const action = { kind: "activity-create", ...input };
-    this.coreRuntime.state.beginWriteCapture();
-    this.coreRuntime.customIdTracker.beginCustomIdTransaction();
-    let result;
-    try {
-      result = createActivitySync(action, {
-        adapter: this.coreRuntime.state,
-        scheduler: this.coreRuntime.scheduler,
-        sector: this.coreRuntime.sector,
-        calendars: this.coreRuntime.calendars,
-        activityIdGen: this.coreRuntime.activityIdGenerator,
-        uidGen: this.coreRuntime.uniqueCorrelativeIdGenerator,
-        customIdTracker: this.coreRuntime.customIdTracker
-      });
-      if (!result.ok) this._rollback();
-    } catch (error) {
-      this._rollback();
-      throw error;
-    } finally {
-      this.coreRuntime.state.endWriteCapture();
-      this.coreRuntime.customIdTracker.commitCustomIdTransaction();
-    }
-    if (!result.ok) return result;
-    return {
-      ok: true,
-      activity: result.activity,
-      changes: result.changes
-    };
+    return this._saveTracker.modifiedActivities(this.coreRuntime.state.getAllActivities()).map(cloneDomainValue);
   }
   _enqueue(work) {
     const workPromise = this._opQueue.then(work, work);
@@ -18801,10 +19115,9 @@ var ScheduleCore = class {
       dateFormat: this.coreRuntime.sector.dateFormat,
       inputUnit: options.inputUnit ?? "days"
     });
-    const undoable = isUndoableAction(action);
+    const historyPolicy = getDispatchHistoryPolicy(action);
     this.coreRuntime.state.beginWriteCapture();
     this.coreRuntime.customIdTracker.beginCustomIdTransaction();
-    this._dispatchInFlight = true;
     let result;
     try {
       result = await dispatch(action, options, {
@@ -18817,6 +19130,7 @@ var ScheduleCore = class {
         linkIdGen: this.coreRuntime.linkIdGenerator,
         uidGen: this.coreRuntime.uniqueCorrelativeIdGenerator,
         customIdTracker: this.coreRuntime.customIdTracker,
+        reporter: this.coreRuntime.reporter,
         defaultBaseCalendarId: this.coreRuntime.baseCalendars.find(
           (calendar) => calendar.baseDefault
         )?.id ?? null,
@@ -18827,11 +19141,10 @@ var ScheduleCore = class {
       this._rollback();
       throw error;
     } finally {
-      this._dispatchInFlight = false;
       this.coreRuntime.state.endWriteCapture();
       this.coreRuntime.customIdTracker.commitCustomIdTransaction();
     }
-    if (result.ok && undoable && changeSetIsSubstantive(result.changes)) {
+    if (result.ok && historyPolicy === "record" && changeSetIsSubstantive(result.changes)) {
       const created = captureCreatedSnapshots(
         this.coreRuntime.state,
         result.changes
@@ -18848,11 +19161,18 @@ var ScheduleCore = class {
         Date.now()
       );
     }
+    if (result.ok && historyPolicy === "clear-on-success") {
+      this._saveTracker.snapshotActivities(
+        this.coreRuntime.state.getAllActivities()
+      );
+      this._saveTracker.snapshotLinks(this.getAllLinksView());
+      this._undo.clear();
+    }
     if (!result.ok) return result;
-    if (changeSetIsSubstantive(result.changes)) {
+    if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
       this._recordScheduleMutation(options.skipCriticalPath !== true);
     }
-    return { ...result, changes: result.changes };
+    return cloneDomainValue(result);
   }
   /**
    * Starts or joins the Critical Path calculation for the current schedule
@@ -18862,9 +19182,11 @@ var ScheduleCore = class {
    * ineligible to commit.
    */
   recomputeCriticalPath() {
-    return this._enqueue(async () => ({
+    const operation = this._enqueue(async () => ({
       job: this._startCriticalPathForCurrentRevision()
     })).then(({ job }) => job);
+    this._criticalPathReady = operation;
+    return operation;
   }
   isCriticalPathSettled() {
     return this._criticalPathRevision === this._scheduleRevision && this._activeCriticalPath === null;
@@ -18985,12 +19307,42 @@ var ScheduleCore = class {
     }
     return { changes };
   }
+  /**
+   * Undo/Redo restores the user's historical mutation while retaining current
+   * non-historical truth (for example a refreshed baseline). Re-derive every
+   * value that depends on both so the restored model is immediately coherent.
+   */
+  _recomputeAfterHistoryRestore() {
+    const state = this.coreRuntime.state;
+    recomputeAllProgressRollup(state);
+    recomputeCanonicalRealWork(state);
+    emitRealCost(state);
+    if (this.coreRuntime.clock) {
+      const now = endOfLocalDay(this.coreRuntime.clock());
+      applyExpectedProgressLive(state, now);
+      let hasActiveBaseline2 = false;
+      state.forEachActivity((activity) => {
+        hasActiveBaseline2 ||= getActiveBaseline(activity) !== null;
+      });
+      if (hasActiveBaseline2) {
+        runExpectedProgressBase(
+          state,
+          now,
+          this.coreRuntime.baseCalendars.find(
+            (calendar) => calendar.baseDefault
+          )?.id ?? null
+        );
+      }
+      applyStatusPass(state, this.coreRuntime.sector.statusCriteria);
+    }
+  }
   undo() {
     const operation = this._enqueue(async () => {
       this.assertReady();
       const entry = this._undo.takeUndo();
       if (!entry) return null;
       applyUndo(this.coreRuntime.state, entry);
+      this._recomputeAfterHistoryRestore();
       this._recordScheduleMutation(false);
       if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
       this._undo.pushRedo(entry);
@@ -19018,6 +19370,7 @@ var ScheduleCore = class {
       const entry = this._undo.takeRedo();
       if (!entry) return null;
       applyRedo(this.coreRuntime.state, entry);
+      this._recomputeAfterHistoryRestore();
       this._recordScheduleMutation(false);
       if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
       this._undo.pushUndo(entry);
@@ -19039,15 +19392,20 @@ var ScheduleCore = class {
     );
     return operation;
   }
-  clearHistory() {
-    this._undo.clear();
-  }
   canUndo() {
     return this._undo.canUndo();
   }
   canRedo() {
     return this._undo.canRedo();
   }
+  /**
+   * Establishes a new persistence boundary without mutating schedule state.
+   * Completed saves call this synchronously so neither prior undo entries nor
+   * their redo branch can cross the persisted boundary.
+   */
+  clearHistory() {
+    this._undo.clear();
+  }
   undoDepth() {
     return this._undo.undoDepth();
   }
@@ -19133,6 +19491,10 @@ var DEFAULT_HOURS_PER_DAY = 8;
 
 // src/dispatch/action-kinds.ts
 var DISPATCH_ACTION_KIND = {
+  PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
+  BASELINE_APPLY: "baseline-apply",
+  PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
+  STATUS_CRITERIA_SET: "status-criteria-set",
   INLINE_EDIT: "inline-edit",
   DATES_BATCH: "dates-batch",
   BULK_EDIT: "bulk-edit",
@@ -19154,6 +19516,10 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
 };
 var KIND_CATALOG_COVERS_UNION = {
+  [DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE]: true,
+  [DISPATCH_ACTION_KIND.BASELINE_APPLY]: true,
+  [DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET]: true,
+  [DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET]: true,
   [DISPATCH_ACTION_KIND.INLINE_EDIT]: true,
   [DISPATCH_ACTION_KIND.DATES_BATCH]: true,
   [DISPATCH_ACTION_KIND.BULK_EDIT]: true,
@@ -19202,7 +19568,6 @@ exports.REJECTION_REASON = REJECTION_REASON;
 exports.ROOT_PARENT_ID = ROOT_PARENT_ID;
 exports.ScheduleCore = ScheduleCore;
 exports.WORK_TIME_DIRECTION = WORK_TIME_DIRECTION;
-exports.applyBaselinePoints = applyBaselinePoints;
 exports.checkNoUpdatedLinks = checkNoUpdatedLinks;
 exports.computeExpectedProgress = computeExpectedProgress;
 exports.expectedProgressFromBaseline = expectedProgressFromBaseline;
@@ -19211,8 +19576,6 @@ exports.getUnsavedActivities = getUnsavedActivities;
 exports.isRootParent = isRootParent;
 exports.normalizeParentKey = normalizeParentKey;
 exports.parseFromBackend = parseFromBackend;
-exports.recomputeAllPonderators = recomputeAllPonderators;
-exports.recomputeAllProgressRollup = recomputeAllProgressRollup;
 exports.willRunCriticalPath = willRunCriticalPath;
 exports.yieldToBrowser = yieldToBrowser;
 //# sourceMappingURL=index.cjs.map