@outbuild-company/schedule-core 1.9.1 → 1.9.3

package/dist/index.cjs

@@ -3289,6 +3289,84 @@ function roundProgressPerLevel(value) {
   return Number(value.toFixed(2));
 }
 
+// src/propagations/upward/progress-rollup.ts
+function recomputeAllProgressRollup(adapter) {
+  for (const parentId of parentsDeepestFirst(adapter)) {
+    rollupParent(parentId, adapter);
+  }
+}
+function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
+  for (const parentId of parentIdsDeepestFirst) {
+    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, depthOf(id, adapter));
+  return [...parents].sort(
+    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
+  );
+}
+function depthOf(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)
+    });
+  }
+  applyWeightedProgressRollup(parentId, children, adapter);
+}
+function applyWeightedProgressRollup(parentId, children, adapter) {
+  const parent = adapter.getActivity(parentId);
+  if (!parent) return;
+  const rollup = computeWeightedProgressRollup(children);
+  if (rollup === null) {
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback !== null) {
+      adapter.setActivityField(parentId, COLUMN.PROGRESS, fallback);
+    }
+    return;
+  }
+  if (adapter.getProgressFallback(parentId) === null) {
+    adapter.setProgressFallback(parentId, Number(parent.progress ?? 0));
+  }
+  adapter.setActivityField(
+    parentId,
+    COLUMN.PROGRESS,
+    roundProgressPerLevel(rollup)
+  );
+}
+function setExplicitSummaryProgressFallbacks(activityId, progress, adapter) {
+  const pending = [activityId];
+  while (pending.length > 0) {
+    const currentId = pending.pop();
+    if (currentId === void 0) continue;
+    const children = adapter.getChildren(currentId);
+    if (children.length === 0) continue;
+    adapter.setProgressFallback(currentId, progress);
+    pending.push(...children);
+  }
+}
+
 // src/columns/real-work/compute.ts
 function computeLeafRealWork(workHours, progress) {
   return (Number(workHours) || 0) * (Number(progress) || 0) / 100;
@@ -3404,16 +3482,8 @@ function recomputeParentFromChildren(parentId, adapter, progressMode = "freeze-w
   adapter.setActivityField(parentId, "startDate", newStart);
   adapter.setActivityField(parentId, "endDate", newEnd);
   adapter.setActivityField(parentId, "durationHours", durationHours);
-  const progressRollup = computeWeightedProgressRollup(
-    aggregate.weightedChildren
-  );
-  const shouldWriteProgress = progressMode !== "skip" && (progressRollup !== null || progressMode === "zero-when-no-contribution");
-  if (shouldWriteProgress) {
-    adapter.setActivityField(
-      parentId,
-      "progress",
-      roundProgressPerLevel(progressRollup ?? 0)
-    );
+  if (progressMode !== "skip") {
+    applyWeightedProgressRollup(parentId, aggregate.weightedChildren, adapter);
   }
   if (recomputeRealWork) {
     adapter.setActivityField(parentId, "realWorkHours", aggregate.realWorkSum);
@@ -3436,10 +3506,10 @@ function collectParentIds(adapter) {
 }
 function computeDepths(ids, adapter) {
   const depths = /* @__PURE__ */ new Map();
-  for (const id of ids) depths.set(id, depthOf(id, adapter));
+  for (const id of ids) depths.set(id, depthOf2(id, adapter));
   return depths;
 }
-function depthOf(id, adapter) {
+function depthOf2(id, adapter) {
   let depth = 0;
   let current = id;
   while (current && !isRootParent(current)) {
@@ -3922,6 +3992,7 @@ function buildAncestorRollupCascade(activity, newValue, hierarchy) {
   const mutations = [];
   for (const id of chain) {
     const rollup = computeWeightedProgress(id, overlay, hierarchy);
+    if (rollup === null) continue;
     overlay.set(id, rollup);
     mutations.push({
       activityId: id,
@@ -3935,7 +4006,8 @@ function computeWeightedProgress(parentId, overlay, hierarchy) {
     progress: overlay.has(child.id) ? overlay.get(child.id) : child.progress,
     ponderator: child.ponderator ?? 0
   }));
-  return Number((computeWeightedProgressRollup(children) ?? 0).toFixed(2));
+  const rollup = computeWeightedProgressRollup(children);
+  return rollup === null ? null : Number(rollup.toFixed(2));
 }
 function buildRecursiveTrackingEvents(activity, newValue) {
   return [
@@ -9886,24 +9958,82 @@ function resolveDerivedPasses(action, autoSchedule, options) {
 
 // src/dispatch/shared/post-mutation.ts
 async function runPostMutation(deps, args) {
-  const passes = resolvePasses(args);
+  const progressInvalidation = resolveProgressInvalidation(deps.adapter);
+  const passes = resolvePasses(args, progressInvalidation);
   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 rollUpParentBounds(
+    deps.adapter,
+    args,
+    schedule.scheduledIds,
+    passes,
+    progressInvalidation
+  );
   await runDerivedRecomputes(deps, passes, args.now);
   return schedule;
 }
-function resolvePasses(args) {
+function resolvePasses(args, progressInvalidation) {
   const requested = args.autoscheduleFrom !== null;
   const ran = !args.options.skipAutoSchedule && requested;
   const passes = new Set(
     resolveDerivedPasses(args.action, { ran }, args.options)
   );
-  if (args.recomputeParentProgress) passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  if (args.recomputeParentProgress || progressInvalidation.affectedParents.size > 0) {
+    passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  }
   return passes;
 }
+function resolveProgressInvalidation(adapter) {
+  const affectedParents = /* @__PURE__ */ new Set();
+  const dirtySeeds = /* @__PURE__ */ new Set();
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return { affectedParents, dirtySeeds };
+  const affectParent = (parentId) => {
+    if (parentId === null || isRootParent(parentId)) return;
+    const normalized2 = String(parentId);
+    affectedParents.add(normalized2);
+    const childId = adapter.getChildren(normalized2)[0];
+    if (childId !== void 0) dirtySeeds.add(childId);
+  };
+  collectStructuralProgressInvalidations(adapter, journal.ops, affectParent);
+  collectFieldProgressInvalidations(
+    adapter,
+    journal.before,
+    dirtySeeds,
+    affectParent
+  );
+  return { affectedParents, dirtySeeds };
+}
+function collectStructuralProgressInvalidations(adapter, operations, affectParent) {
+  for (const operation of operations) {
+    if (operation.kind === "insert") {
+      const inserted = adapter.getActivity(operation.activityId);
+      if (inserted) affectParent(inserted.parentId);
+    } else if (operation.kind === "remove") {
+      affectParent(operation.before.parentId);
+    }
+  }
+}
+function collectFieldProgressInvalidations(adapter, beforeById, dirtySeeds, affectParent) {
+  for (const [activityId, before] of beforeById) {
+    const after = adapter.getActivity(activityId);
+    if (!after) continue;
+    const progressChanged = !Object.is(before.progress, after.progress);
+    const ponderatorChanged = !Object.is(before.ponderator, after.ponderator);
+    const parentChanged = !Object.is(before.parentId, after.parentId);
+    if (progressChanged || ponderatorChanged) {
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+    if (parentChanged) {
+      affectParent(before.parentId);
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+  }
+}
 async function runAutoschedule(deps, autoscheduleFrom) {
   const options = autoscheduleFrom === "roots" ? {} : { triggerId: autoscheduleFrom };
   const result = await deps.scheduler.schedule(options);
@@ -9931,18 +10061,36 @@ async function refreshMutatedParentBounds(adapter, args) {
   if (mutated.size === 0) return;
   await updateParentBoundsFromChildren(adapter, mutated, false);
 }
-async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
+async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressInvalidation) {
+  if (passes.has(DERIVED_PASS.PARENT_PROGRESS)) {
+    restoreDemotedProgressFallbacks(
+      adapter,
+      progressInvalidation.affectedParents
+    );
+  }
   const dirty = args.collectDirty ? args.collectDirty(scheduledIds) : collectDirtyForStructural(args.recomputeParentsFrom, scheduledIds);
+  for (const activityId of progressInvalidation.dirtySeeds) {
+    dirty.add(activityId);
+  }
   await updateParentBoundsFromChildren(
     adapter,
     dirty,
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
       recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
-      progressMode: args.recomputeParentProgress ? "zero-when-no-contribution" : "freeze-when-no-contribution"
+      progressMode: "freeze-when-no-contribution"
     }
   );
 }
+function restoreDemotedProgressFallbacks(adapter, affectedParents) {
+  for (const parentId of affectedParents) {
+    if (adapter.hasChildren(parentId)) continue;
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback === null) continue;
+    adapter.setActivityField(parentId, "progress", fallback);
+    adapter.setProgressFallback(parentId, null);
+  }
+}
 async function runDerivedRecomputes(deps, passes, now) {
   if (passes.has(DERIVED_PASS.EXPECTED_PROGRESS) && now !== null) {
     if (hasActiveBaseline(deps.adapter)) {
@@ -11171,7 +11319,6 @@ function buildParentMutations(input) {
     if ((input.promotionSource ?? "create") === "create") {
       fields.constraintType = CONSTRAINT_TYPE.ASAP;
       fields.constraintDate = null;
-      fields.progress = 0;
     }
   }
   return {
@@ -12324,60 +12471,6 @@ function dispatchSirSync(action, deps) {
   };
 }
 
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
-  }
-}
-function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
-  for (const parentId of parentIdsDeepestFirst) {
-    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/handlers/persistence-acknowledge.ts
 function persistedOwnersOf(entities) {
   const owners = /* @__PURE__ */ new Map();
@@ -12450,28 +12543,6 @@ function assertValidAssignments(assignments, entityName, readCurrent, ownerByBac
     );
   }
 }
-function assertValidReconciledProgress(entries, deps) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const id = String(entry.activityId);
-    if (id.length === 0 || seen.has(id)) {
-      throw new Error(
-        `persistence-acknowledge: duplicate or empty reconciled activity id "${id}"`
-      );
-    }
-    if (!Number.isFinite(entry.progress) || entry.progress < 0 || entry.progress > 100) {
-      throw new Error(
-        `persistence-acknowledge: invalid reconciled progress ${String(entry.progress)} for "${id}"`
-      );
-    }
-    if (!deps.adapter.getActivity(id)) {
-      throw new Error(
-        `persistence-acknowledge: unknown reconciled activity id "${id}"`
-      );
-    }
-    seen.add(id);
-  }
-}
 async function applyReconciledProgress(entries, deps) {
   const progressToApply = entries.filter((entry) => {
     const current = deps.adapter.getActivity(String(entry.activityId));
@@ -12502,19 +12573,25 @@ async function applyReconciledProgress(entries, deps) {
 async function dispatchPersistenceAcknowledge(action, deps) {
   const activities = action.activities ?? [];
   const links = action.links ?? [];
-  const reconciledProgress = action.reconciledProgress ?? [];
-  assertValidReconciledProgress(reconciledProgress, deps);
   const currentActivities = deps.adapter.getAllActivities();
   const currentLinks = deps.adapter.getAllLinks();
-  const activityOwnerByBackendId = persistedOwnersOf(currentActivities);
-  const linkOwnerByBackendId = persistedOwnersOf(currentLinks);
+  const checkpointActivities = action.checkpoint?.activities ?? currentActivities;
+  const checkpointLinks = action.checkpoint?.links ?? currentLinks;
+  const checkpointActivityById = new Map(
+    checkpointActivities.map((activity) => [String(activity.id), activity])
+  );
+  const checkpointLinkById = new Map(
+    checkpointLinks.map((link) => [String(link.id), link])
+  );
+  const activityOwnerByBackendId = persistedOwnersOf(checkpointActivities);
+  const linkOwnerByBackendId = persistedOwnersOf(checkpointLinks);
   assertValidAssignments(
     activities,
     "activity",
     (id) => {
-      const activity = deps.adapter.getActivity(id);
+      const activity = checkpointActivityById.get(id);
       return {
-        exists: activity !== null,
+        exists: activity !== void 0,
         current: activity?.proplannerId ?? null
       };
     },
@@ -12524,17 +12601,21 @@ async function dispatchPersistenceAcknowledge(action, deps) {
     links,
     "link",
     (id) => {
-      const link = deps.adapter.getLink(id);
-      return { exists: link !== null, current: link?.proplannerId ?? null };
+      const link = checkpointLinkById.get(id);
+      return {
+        exists: link !== void 0,
+        current: link?.proplannerId ?? null
+      };
     },
     linkOwnerByBackendId
   );
-  assertAllNewEntitiesAcknowledged(currentActivities, activities, "activity");
-  assertAllNewEntitiesAcknowledged(currentLinks, links, "link");
-  const activityChanges = await applyReconciledProgress(
-    reconciledProgress,
-    deps
+  assertAllNewEntitiesAcknowledged(
+    checkpointActivities,
+    activities,
+    "activity"
   );
+  assertAllNewEntitiesAcknowledged(checkpointLinks, links, "link");
+  const activityChanges = [];
   const linkChanges = [];
   deps.adapter.batchUpdate(() => {
     for (const assignment of activities) {
@@ -13444,6 +13525,11 @@ async function dispatchActivitySetProgress(action, options, deps) {
   const touchedIds = collectTouchedIds(action.activityId, changes);
   const beforeSnap = await snapshotActivities(adapter, touchedIds);
   applyFieldChanges(adapter, action.activityId, changes);
+  setExplicitSummaryProgressFallbacks(
+    action.activityId,
+    action.newValue,
+    adapter
+  );
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
@@ -17307,7 +17393,8 @@ var WriteCapture = class {
       ops: [],
       linkFieldCaptured: /* @__PURE__ */ new Set(),
       correlativeBefore: /* @__PURE__ */ new Map(),
-      scheduledBefore: /* @__PURE__ */ new Map()
+      scheduledBefore: /* @__PURE__ */ new Map(),
+      progressFallbackBefore: /* @__PURE__ */ new Map()
     };
   }
   peek() {
@@ -17370,6 +17457,11 @@ var WriteCapture = class {
       before: cloneLink(current)
     });
   }
+  noteProgressFallback(activityId, current) {
+    const journal = this._journal;
+    if (!journal || journal.progressFallbackBefore.has(activityId)) return;
+    journal.progressFallbackBefore.set(activityId, current);
+  }
 };
 function cloneLink(link) {
   return { ...link };
@@ -17615,6 +17707,7 @@ var ScheduleState = class _ScheduleState {
   _activities = /* @__PURE__ */ new Map();
   _lastStartDate = /* @__PURE__ */ new Map();
   _promotionSnapshot = /* @__PURE__ */ new Map();
+  _progressFallback = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
@@ -17675,6 +17768,7 @@ var ScheduleState = class _ScheduleState {
         cloneDomainValue(snapshot)
       ])
     );
+    fork._progressFallback = new Map(this._progressFallback);
     fork._flags = cloneDomainValue(this._flags);
     fork._filterProjection = cloneDomainValue(this._filterProjection);
     return fork;
@@ -17728,6 +17822,17 @@ var ScheduleState = class _ScheduleState {
     this._capturePromotionSnapshotOnce();
     this._promotionSnapshot.set(String(activityId), snapshot);
   }
+  getProgressFallback(activityId) {
+    return this._progressFallback.get(String(activityId)) ?? null;
+  }
+  setProgressFallback(activityId, value) {
+    const key = String(activityId);
+    const current = this._progressFallback.get(key) ?? null;
+    if (Object.is(current, value)) return;
+    this._writeCapture.noteProgressFallback(key, current);
+    if (value === null) this._progressFallback.delete(key);
+    else this._progressFallback.set(key, value);
+  }
   _capturePromotionSnapshotOnce() {
     if (this._writeCapture.peek() === null) return;
     if (this._promotionSnapshotBefore === null) {
@@ -17978,6 +18083,7 @@ var ScheduleState = class _ScheduleState {
     const activity = this.getActivity(activityId);
     if (activity) this._writeCapture.noteRemove(String(activityId), activity);
     const key = String(activityId);
+    this.setProgressFallback(key, null);
     if (this._viewState.isChecked(key) || !this._viewState.isVisible(key)) {
       this._captureViewStateOnce();
     }
@@ -18002,7 +18108,13 @@ var ScheduleState = class _ScheduleState {
   restoreFromCapture() {
     const journal = this._writeCapture.peek();
     if (!journal) return;
-    const { ops, before, correlativeBefore, scheduledBefore } = journal;
+    const {
+      ops,
+      before,
+      correlativeBefore,
+      scheduledBefore,
+      progressFallbackBefore
+    } = journal;
     this._undoLinkAdds(ops);
     this._undoInserts(ops);
     this._reInsertRemovedActivities(ops);
@@ -18011,6 +18123,7 @@ var ScheduleState = class _ScheduleState {
     this._restoreCorrelatives(correlativeBefore);
     this._restoreActivityFields(scheduledBefore);
     this._restoreActivityFields(before);
+    this._restoreProgressFallbacks(progressFallbackBefore);
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
       this._filterProjection = null;
@@ -18026,6 +18139,12 @@ var ScheduleState = class _ScheduleState {
     this._cache.visualOrderIds = null;
     this._hierarchy.markDirty();
   }
+  _restoreProgressFallbacks(before) {
+    for (const [activityId, value] of before) {
+      if (value === null) this._progressFallback.delete(activityId);
+      else this._progressFallback.set(activityId, value);
+    }
+  }
   _restoreCorrelatives(correlativeBefore) {
     for (const [id, before] of correlativeBefore) {
       const live = this._activities.get(id);
@@ -18239,13 +18358,15 @@ function buildHistoryChangeSet(changes) {
     links: linksWithoutAfter
   });
 }
-function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
+function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, progressFallbackBefore, progressFallbackAfter) {
   return {
     changeSet,
     beforeSnap,
     beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
     afterSnap,
-    afterLinks: resetDerivedLinkSnapshots(afterLinks)
+    afterLinks: resetDerivedLinkSnapshots(afterLinks),
+    progressFallbackBefore,
+    progressFallbackAfter
   };
 }
 function resetDerivedLinkSnapshots(snapshots) {
@@ -18308,7 +18429,9 @@ function mergeCoalesced(top, next) {
   return buildUndoEntry(changeSet);
 }
 function getDispatchHistoryPolicy(action) {
-  if (action.kind === "persistence-acknowledge") return "clear-on-success";
+  if (action.kind === "persistence-acknowledge") {
+    return "checkpoint-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" || action.kind === "activity-clipboard-clear" || action.kind === "activity-copy" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
     return "skip";
   }
@@ -18548,6 +18671,10 @@ function applyChangeSetSide(state, entry, side) {
       );
     }
   }
+  const progressFallbacks = side === "before" ? entry.progressFallbackBefore : entry.progressFallbackAfter;
+  for (const [activityId, value] of progressFallbacks ?? []) {
+    state.setProgressFallback(activityId, value);
+  }
 }
 
 // src/dispatch/undo/undo-recorder.ts
@@ -18560,22 +18687,25 @@ var UndoRecorder = class _UndoRecorder {
   maxDepth;
   undoStack = [];
   redoStack = [];
+  sequence = 0;
   _lastKey = null;
   _lastTime = 0;
   fork() {
     const fork = new _UndoRecorder(this.maxDepth);
     fork.undoStack.push(...cloneDomainValue(this.undoStack));
     fork.redoStack.push(...cloneDomainValue(this.redoStack));
+    fork.sequence = this.sequence;
     fork._lastKey = this._lastKey;
     fork._lastTime = this._lastTime;
     return fork;
   }
   record(entry, coalesceKey = null, now = 0) {
     const top = this.undoStack[this.undoStack.length - 1];
-    if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top, entry)) {
-      this.undoStack[this.undoStack.length - 1] = mergeCoalesced(top, entry);
+    if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top.entry, entry)) {
+      top.entry = mergeCoalesced(top.entry, entry);
+      top.touchedAt = this.touch();
     } else {
-      this.undoStack.push(entry);
+      this.undoStack.push({ entry, touchedAt: this.touch() });
       if (this.undoStack.length > this.maxDepth) {
         this.undoStack.splice(0, this.undoStack.length - this.maxDepth);
       }
@@ -18588,16 +18718,16 @@ var UndoRecorder = class _UndoRecorder {
     this._lastKey = null;
   }
   takeUndo() {
-    return this.undoStack.pop() ?? null;
+    return this.undoStack.pop()?.entry ?? null;
   }
   takeRedo() {
-    return this.redoStack.pop() ?? null;
+    return this.redoStack.pop()?.entry ?? null;
   }
   pushRedo(entry) {
-    this.redoStack.push(entry);
+    this.redoStack.push({ entry, touchedAt: this.touch() });
   }
   pushUndo(entry) {
-    this.undoStack.push(entry);
+    this.undoStack.push({ entry, touchedAt: this.touch() });
   }
   canUndo() {
     return this.undoStack.length > 0;
@@ -18608,11 +18738,64 @@ var UndoRecorder = class _UndoRecorder {
   undoDepth() {
     return this.undoStack.length;
   }
+  capturePersistenceBoundary() {
+    this.resetCoalesce();
+    return this.sequence;
+  }
+  discardThrough(boundary) {
+    this.removeEntriesThrough(this.undoStack, boundary);
+    this.removeEntriesThrough(this.redoStack, boundary);
+    this.resetCoalesce();
+  }
+  applyPersistedIdentities(activities, links) {
+    const activityIds = new Map(
+      activities.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    const linkIds = new Map(
+      links.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    for (const stored of [...this.undoStack, ...this.redoStack]) {
+      stored.entry = this.withPersistedIdentities(
+        stored.entry,
+        activityIds,
+        linkIds
+      );
+    }
+  }
   clear() {
     this.undoStack.length = 0;
     this.redoStack.length = 0;
     this.resetCoalesce();
   }
+  touch() {
+    this.sequence += 1;
+    return this.sequence;
+  }
+  removeEntriesThrough(stack, boundary) {
+    const retained = stack.filter(({ touchedAt }) => touchedAt > boundary);
+    stack.splice(0, stack.length, ...retained);
+  }
+  withPersistedIdentities(entry, activityIds, linkIds) {
+    const patchActivities = (snapshots) => snapshots === void 0 ? void 0 : new Map(
+      Array.from(snapshots, ([id, activity]) => [
+        id,
+        activityIds.has(id) ? { ...activity, proplannerId: activityIds.get(id) } : activity
+      ])
+    );
+    const patchLinks = (snapshots) => snapshots === void 0 ? void 0 : new Map(
+      Array.from(snapshots, ([id, link]) => [
+        id,
+        linkIds.has(id) ? { ...link, proplannerId: linkIds.get(id) } : link
+      ])
+    );
+    return {
+      ...entry,
+      beforeSnap: patchActivities(entry.beforeSnap),
+      afterSnap: patchActivities(entry.afterSnap),
+      beforeLinks: patchLinks(entry.beforeLinks),
+      afterLinks: patchLinks(entry.afterLinks)
+    };
+  }
 };
 
 // src/dispatch/shared/resequenced-parents.ts
@@ -18770,10 +18953,12 @@ function snapshotFieldValue(field, value) {
   return value;
 }
 function activityChangedSince(current, saved) {
-  for (const field of PERSISTABLE_ACTIVITY_FIELDS) {
-    if (!fieldEquals(field, current[field], saved[field])) return true;
-  }
-  return false;
+  return changedPersistableActivityFields(current, saved).length > 0;
+}
+function changedPersistableActivityFields(current, saved) {
+  return PERSISTABLE_ACTIVITY_FIELDS.filter(
+    (field) => !fieldEquals(field, current[field], saved[field])
+  );
 }
 function fieldEquals(field, currentValue, savedValue) {
   if (DATE_FIELDS2.has(field)) return dateEquals(currentValue, savedValue);
@@ -18882,11 +19067,60 @@ var SaveTracker = class _SaveTracker {
     }
     this.initialized = true;
   }
-  acknowledge(activities, links) {
+  acknowledge(activities, links, activityIdentities = [], linkIdentities = [], currentActivities, currentLinks) {
     if (!this.trackingEnabled) return;
-    assertValidPersistedIdentities(activities, links);
-    this.snapshotActivities(activities);
-    this.snapshotLinks(links);
+    const activityIds = new Map(
+      activityIdentities.map(({ id, proplannerId }) => [
+        String(id),
+        proplannerId
+      ])
+    );
+    const linkIds = new Map(
+      linkIdentities.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    const persistedActivities = activities.map((activity) => ({
+      ...activity,
+      proplannerId: activityIds.get(String(activity.id)) ?? activity.proplannerId
+    }));
+    const persistedLinks = links.map((link) => {
+      const proplannerId = linkIds.get(String(link.id));
+      return proplannerId === void 0 ? { ...link } : { ...link, proplannerId };
+    });
+    assertValidPersistedIdentities(persistedActivities, persistedLinks);
+    this.snapshotActivities(persistedActivities);
+    this.snapshotLinks(persistedLinks);
+    if (!currentActivities || !currentLinks) return;
+    const currentActivityById = new Map(
+      currentActivities.map((activity) => [String(activity.id), activity])
+    );
+    const currentLinkById = new Map(
+      currentLinks.map((link) => [String(link.id), link])
+    );
+    for (const activity of persistedActivities) {
+      const activityId = String(activity.id);
+      if (this.activityIsDirty(
+        activityId,
+        currentActivityById.get(activityId) ?? null
+      )) {
+        this.dirtyActivityIds.add(activityId);
+      }
+    }
+    for (const activity of currentActivities) {
+      const activityId = String(activity.id);
+      if (this.activityIsDirty(activityId, activity)) {
+        this.dirtyActivityIds.add(activityId);
+      }
+    }
+    for (const link of persistedLinks) {
+      const linkId = String(link.id);
+      if (this.linkIsDirty(linkId, currentLinkById.get(linkId) ?? null)) {
+        this.dirtyLinkIds.add(linkId);
+      }
+    }
+    for (const link of currentLinks) {
+      const linkId = String(link.id);
+      if (this.linkIsDirty(linkId, link)) this.dirtyLinkIds.add(linkId);
+    }
   }
   snapshotActivities(activities) {
     if (!this.trackingEnabled) return;
@@ -19070,6 +19304,21 @@ var SaveTracker = class _SaveTracker {
     }
     return modified;
   }
+  modifiedActivityFields(getActivity) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.trackingEnabled || !this.initialized) return result;
+    for (const activityId of this.dirtyActivityIds) {
+      const current = getActivity(activityId);
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (!current || !saved) continue;
+      const fields = changedPersistableActivityFields(
+        current,
+        saved.persistable
+      );
+      if (fields.length > 0) result.set(activityId, fields);
+    }
+    return result;
+  }
   modifiedLinks(getLink) {
     if (!this.trackingEnabled || !this.initialized) return [];
     const modified = [];
@@ -20439,6 +20688,7 @@ async function runInitialPasses(deps) {
   normalizeLoadedConstraintDates(state);
   recomputeCanonicalRealWork(state);
   if (skipAutoSchedule) {
+    recomputeAllProgressRollup(state);
     if (now) {
       applyExpectedProgressLive(state, now);
       applyStatusPass(state, sector.statusCriteria);
@@ -20450,6 +20700,7 @@ async function runInitialPasses(deps) {
   normalizeMilestoneConstraintDatesForDisplay(state);
   recomputeSkippedLeafEnds(state);
   await updateParentBoundsFromChildren(state, void 0, false);
+  recomputeAllProgressRollup(state);
   if (now) {
     applyExpectedProgressLive(state, now);
     applyStatusPass(state, sector.statusCriteria);
@@ -21160,6 +21411,14 @@ var ScheduleCore = class _ScheduleCore {
       (activityId) => this.coreRuntime.state.getActivity(activityId)
     ).map(cloneDomainValue);
   }
+  getModifiedActivityFields() {
+    this.assertReady();
+    return cloneDomainValue(
+      this._saveTracker.modifiedActivityFields(
+        (activityId) => this.coreRuntime.state.getActivity(activityId)
+      )
+    );
+  }
   getNewActivities() {
     this.assertReady();
     return this._saveTracker.newActivities(
@@ -21173,6 +21432,10 @@ var ScheduleCore = class _ScheduleCore {
   getScheduleRevision() {
     return this._scheduleRevision;
   }
+  capturePersistenceHistoryBoundary() {
+    this.assertReady();
+    return this._undo.capturePersistenceBoundary();
+  }
   getCanonicalDigest() {
     this.assertReady();
     const byId = (left, right) => String(left.id).localeCompare(String(right.id));
@@ -21284,6 +21547,7 @@ var ScheduleCore = class _ScheduleCore {
     this.coreRuntime.state.beginWriteCapture();
     this.coreRuntime.customIdTracker.beginCustomIdTransaction();
     let result;
+    let progressFallbackBefore;
     try {
       result = await performDispatch(action, options, {
         adapter: this.coreRuntime.state,
@@ -21304,6 +21568,10 @@ var ScheduleCore = class _ScheduleCore {
         )?.id ?? null,
         now: this.coreRuntime.clock ? endOfLocalDay(this.coreRuntime.clock()) : null
       });
+      const fallbackBefore = this.coreRuntime.state.peekWriteCapture()?.progressFallbackBefore;
+      if (fallbackBefore && fallbackBefore.size > 0) {
+        progressFallbackBefore = new Map(fallbackBefore);
+      }
       if (!result.ok) this._rollback(generatorSnapshot);
     } catch (error) {
       this._rollback(generatorSnapshot);
@@ -21317,25 +21585,50 @@ var ScheduleCore = class _ScheduleCore {
         this.coreRuntime.state,
         result.changes
       );
+      const progressFallbackAfter = progressFallbackBefore ? new Map(
+        Array.from(progressFallbackBefore.keys(), (activityId) => [
+          activityId,
+          this.coreRuntime.state.getProgressFallback(activityId)
+        ])
+      ) : void 0;
       this._undo.record(
         buildUndoEntry(
           buildHistoryChangeSet(result.changes),
           result.__beforeSnap,
           result.__beforeLinks,
           created.afterSnap,
-          created.afterLinks
+          created.afterLinks,
+          progressFallbackBefore,
+          progressFallbackAfter
         ),
         computeCoalesceKey(action),
         Date.now()
       );
     }
     if (result.ok) {
-      if (historyPolicy === "clear-on-success") {
+      if (historyPolicy === "checkpoint-on-success") {
+        if (action.kind !== "persistence-acknowledge") {
+          throw new Error(
+            "checkpoint-on-success requires persistence acknowledge"
+          );
+        }
+        const currentActivities = this.coreRuntime.state.getAllActivities();
+        const currentLinks = this.coreRuntime.state.getAllLinks();
+        const checkpoint = action.checkpoint;
+        const boundary = checkpoint?.historyBoundary ?? this._undo.capturePersistenceBoundary();
         this._saveTracker.acknowledge(
-          this.coreRuntime.state.getAllActivities(),
-          this.coreRuntime.state.getAllLinks()
+          checkpoint?.activities ?? currentActivities,
+          checkpoint?.links ?? currentLinks,
+          action.activities,
+          action.links,
+          currentActivities,
+          currentLinks
+        );
+        this._undo.discardThrough(boundary);
+        this._undo.applyPersistedIdentities(
+          action.activities ?? [],
+          action.links ?? []
         );
-        this._undo.clear();
       } else if (action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true) {
         this._saveTracker.acknowledgePersistedLookahead(
           result.changes.activities,