@outbuild-company/schedule-core 1.1.1 → 1.1.2

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,115 +900,98 @@ 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,
+      adapter,
       virtualIdCounter
     );
   }
   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;
+function isInternalSummaryLink(link, sourceIsSummary, targetIsSummary, adapter) {
+  return targetIsSummary && isDescendantOf(link.source, link.target, adapter) || sourceIsSummary && isDescendantOf(link.target, link.source, adapter);
+}
+function expandedEndpoints(activityId, summary, adapter, linksByActivity, sourceSide) {
+  if (!summary) return [activityId];
+  return filterToChainEndpoints(
+    getLeafDescendants(activityId, adapter),
+    adapter,
+    linksByActivity,
+    sourceSide
+  );
+}
+function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, adapter, virtualIdCounter) {
   const source = adapter.getActivity(originalLink.source);
+  const target = adapter.getActivity(originalLink.target);
+  const targetStart = target?.startDate;
+  const userLag = originalLink.lag ?? 0;
+  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;
+  const sourceLag = sourceEndpointIsStart ? -(source?.durationHours ?? 0) : 0;
+  const targetLag = targetEndpointIsFinish ? -(target?.durationHours ?? 0) : 0;
   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
-      });
+      expanded.push(
+        buildVirtualLink(
+          originalLink,
+          srcId,
+          tgtId,
+          counter,
+          sourceLag,
+          targetLag,
+          userLag,
+          source,
+          targetStart,
+          adapter
+        )
+      );
       counter += 1;
     }
   }
   return counter;
 }
-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;
-  });
-  return kept.length > 0 ? kept : leaves;
-}
-function pushExpandedLinks(expanded, sourceIds, targetIds, originalLink, virtualIdCounter) {
-  let counter = virtualIdCounter;
-  for (const srcId of sourceIds) {
-    for (const tgtId of targetIds) {
-      if (String(srcId) === String(tgtId)) continue;
-      expanded.push({
-        id: `virtual_${originalLink.id}_${counter}`,
-        source: srcId,
-        target: tgtId,
-        type: originalLink.type,
-        lag: originalLink.lag
-      });
-      counter += 1;
-    }
-  }
-  return counter;
+function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, userLag, source, targetStart, adapter) {
+  const leaf = adapter.getActivity(targetId);
+  const offTarget = targetStart && leaf && source ? adapter.calculateDuration({
+    startDate: targetStart,
+    endDate: leaf.startDate,
+    task: source
+  }) : 0;
+  return {
+    id: `virtual_${originalLink.id}_${counter}`,
+    source: sourceId,
+    target: targetId,
+    type: originalLink.type,
+    lag: originalLink.lag,
+    _sourceLag: sourceLag,
+    _targetLag: targetLag,
+    _trueLag: userLag + offTarget
+  };
 }
 
 // src/autoscheduler/utils/expanded-links-cache.ts
@@ -2260,12 +2257,6 @@ async function updateParentBoundsFromChildren(adapter, dirtyIds, recomputeProgre
     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);
 }
@@ -3766,6 +3757,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,
@@ -3919,6 +3911,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,594 +4017,290 @@ 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;
+  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 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;
+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 null;
+  return false;
 }
-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 isValidDate2(obj) {
+  return isDate(obj) && !isNaN(obj.getTime());
 }
-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);
+
+// 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 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;
-}
-function setHas(set, id) {
-  if (set.has(id)) return true;
-  return set.has(String(id));
+  const dateToCalculate = date2;
+  return activityCalendar.calculateEndDate({
+    start_date: new Date(dateToCalculate),
+    duration,
+    unit: "hour",
+    task: activity
+  });
 }
 
-// src/internal/hierarchy/recompute-correlative-ids.ts
-function recomputeCorrelativeIds(adapter) {
-  adapter.invalidateVisualOrderIds?.();
-  const roots = [];
-  adapter.forEachActivity((activity) => {
-    if (isRootParent(activity.parentId)) roots.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
   });
-  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;
+  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
+    const isLinkedWithCalculatedOrSibling = linkedActivities.every(
+      (linkedActivityId) => calculations.has(linkedActivityId)
     );
-  });
+    if (isLinkedWithCalculatedOrSibling) {
+      calculableChildren.push(activity);
+    }
+  }
+  return calculableChildren;
 }
-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
-    );
-  });
+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/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;
+// 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());
 }
-
-// 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 getChainStartActivities(gantt, linkProperty) {
+  return gantt.getTaskByTime().filter(filters_default.avoidSubproject).filter(filters_default.byTaskTypeAndMilestone).filter((activity) => !activity[linkProperty].length);
 }
-
-// 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
+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 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 {
+    chainStartActivities: withoutLinkedParents,
+    activitiesStartChainButChildrenOfLinkedParents
   };
-  return linkMap[Number(code)] || "sf";
 }
 
-// src/critical-path/legacy/base/identifiers/secondLevelActivities.js
-function identifySecondLevelActivities(params) {
-  const { gantt, pendingParentsWithNoLinks, calculations, linkProperty } = params;
+// src/critical-path/legacy/base/identifiers/identifyParentsWithAndWithoutLinks.js
+function identifyParentsWithAndWithoutLinks({
+  gantt,
+  direction,
+  linkProperty
+}) {
   try {
-    const subprojectsWithNoLinks = getSubprojectsWithNoLinks({
-      gantt,
-      pendingParentsWithNoLinks
-    });
-    if (subprojectsWithNoLinks.length === 0) {
-      return /* @__PURE__ */ new Set();
+    const allParentActivities = getAllParentActivities(gantt);
+    const parentsWithFullProgress = /* @__PURE__ */ new Set();
+    const pendingParentsWithNoLinks = /* @__PURE__ */ new Set();
+    const pendingParentsWithLinks = /* @__PURE__ */ new Set();
+    if (direction === "backward") {
+      const parentsWithFullProgressArray = getParentsWithFullProgress(allParentActivities);
+      parentsWithFullProgressArray.forEach((activity) => {
+        parentsWithFullProgress.add(activity.id);
+      });
     }
-    const allChildrenFromParents = getAllChildrenFromParents({
-      gantt,
-      subprojectsWithNoLinks
+    const parentsWithNoLinks = getParentsWithNoLinks(
+      allParentActivities,
+      direction,
+      linkProperty
+    );
+    const difference = getDifference(allParentActivities, parentsWithNoLinks);
+    parentsWithNoLinks.forEach((activity) => {
+      pendingParentsWithNoLinks.add(activity.id);
     });
-    const childrenThatCanBeCalculated = filterChildrenThatCanBeCalculated({
-      gantt,
-      childrenIds: allChildrenFromParents,
-      linkProperty,
-      getArrayOfLinkedActivities,
-      calculations
+    difference.forEach((activity) => {
+      pendingParentsWithLinks.add(activity.id);
     });
-    return new Set(childrenThatCanBeCalculated.map((activity) => activity.id));
+    return {
+      parentsWithFullProgress,
+      pendingParentsWithNoLinks,
+      pendingParentsWithLinks
+    };
   } 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
-  };
-}
-
-// src/critical-path/legacy/base/identifiers/identifyParentsWithAndWithoutLinks.js
-function identifyParentsWithAndWithoutLinks({
-  gantt,
-  direction,
-  linkProperty
-}) {
-  try {
-    const allParentActivities = getAllParentActivities(gantt);
-    const parentsWithFullProgress = /* @__PURE__ */ new Set();
-    const pendingParentsWithNoLinks = /* @__PURE__ */ new Set();
-    const pendingParentsWithLinks = /* @__PURE__ */ new Set();
-    if (direction === "backward") {
-      const parentsWithFullProgressArray = getParentsWithFullProgress(allParentActivities);
-      parentsWithFullProgressArray.forEach((activity) => {
-        parentsWithFullProgress.add(activity.id);
-      });
-    }
-    const parentsWithNoLinks = getParentsWithNoLinks(
-      allParentActivities,
-      direction,
-      linkProperty
-    );
-    const difference = getDifference(allParentActivities, parentsWithNoLinks);
-    parentsWithNoLinks.forEach((activity) => {
-      pendingParentsWithNoLinks.add(activity.id);
-    });
-    difference.forEach((activity) => {
-      pendingParentsWithLinks.add(activity.id);
-    });
-    return {
-      parentsWithFullProgress,
-      pendingParentsWithNoLinks,
-      pendingParentsWithLinks
-    };
-  } catch (e) {
-    throw e;
-  }
-}
-function getAllParentActivities(gantt) {
-  return gantt.getTaskByTime().filter(filters_default.filterByParentType).filter(filters_default.avoidSubproject);
+function getAllParentActivities(gantt) {
+  return gantt.getTaskByTime().filter(filters_default.filterByParentType).filter(filters_default.avoidSubproject);
 }
 function getParentsWithNoLinks(activities, direction, linkProperty) {
   return activities.filter((activity) => {
@@ -9491,13 +9250,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 +9274,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,
@@ -10233,26 +10000,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,79 +10085,201 @@ var DISPATCH_TRACK_EVENT = {
   ACTIVITY_OUTDENT: "schedule_activity_outdent"
 };
 
-// src/propagations/upward/recompute-hh-cascade.ts
-function recomputeHhCascadeForParent(startParentId, adapter) {
-  if (!startParentId || startParentId === "0") return;
-  let currentParentId = String(startParentId);
-  while (currentParentId !== null) {
-    const childIds = adapter.getChildren(currentParentId);
-    let hhSum = 0;
-    let rwSum = 0;
+// 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) continue;
-      const hh = readNumber(child, ACTIVITY_PROPERTY.WORK_HOURS);
-      const rw = readChildRealWork(childId, child, hh, adapter);
-      hhSum += hh;
-      rwSum += rw;
+      if (child) visit(child);
     }
-    adapter.setActivityField(
-      currentParentId,
-      ACTIVITY_PROPERTY.WORK_HOURS,
-      hhSum
-    );
-    adapter.setActivityField(
-      currentParentId,
-      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
-      rwSum
-    );
-    const parentSnap = adapter.getActivity(currentParentId);
-    if (!parentSnap) break;
-    const grandParent = parentSnap.parentId;
-    if (!grandParent || isRootParent(grandParent)) break;
-    currentParentId = grandParent;
+  };
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  for (const rootId of rootIds) {
+    const root = adapter.getActivity(rootId);
+    if (root) visit(root);
   }
+  return result;
 }
-function recomputeHhCascadeForActivity(activityId, adapter) {
-  const activity = adapter.getActivity(activityId);
-  if (!activity) return;
-  const parentId = activity.parentId;
-  if (!parentId || isRootParent(parentId)) return;
-  recomputeHhCascadeForParent(parentId, adapter);
-}
-function readNumber(activity, key) {
-  const v = activity[key];
-  if (typeof v === "number" && Number.isFinite(v)) return v;
-  return 0;
+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 readChildRealWork(childId, child, workHours, adapter) {
-  return adapter.hasChildren(childId) ? readNumber(child, ACTIVITY_PROPERTY.REAL_WORK_HOURS) : computeLeafRealWork(
-    workHours,
-    readNumber(child, ACTIVITY_PROPERTY.PROGRESS)
-  );
+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));
 }
-
-// src/propagations/upward/recompute-used-cost-cascade.ts
-function recomputeUsedCostCascadeForParent(startParentId, adapter) {
-  if (!startParentId || startParentId === "0") return;
-  let currentParentId = String(startParentId);
-  while (currentParentId !== null) {
-    const childIds = adapter.getChildren(currentParentId);
-    let sum = 0;
-    for (const childId of childIds) {
-      const child = adapter.getActivity(childId);
-      if (!child) continue;
-      sum += readNumber2(child, ACTIVITY_PROPERTY.USED_COST);
-    }
-    adapter.setActivityField(currentParentId, ACTIVITY_PROPERTY.USED_COST, sum);
-    const parentSnap = adapter.getActivity(currentParentId);
-    if (!parentSnap) break;
-    const grandParent = parentSnap.parentId;
-    if (!grandParent || isRootParent(grandParent)) break;
-    currentParentId = grandParent;
+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 recomputeUsedCostCascadeForActivity(activityId, adapter) {
+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;
+  let currentParentId = String(startParentId);
+  while (currentParentId !== null) {
+    const childIds = adapter.getChildren(currentParentId);
+    let hhSum = 0;
+    let rwSum = 0;
+    for (const childId of childIds) {
+      const child = adapter.getActivity(childId);
+      if (!child) continue;
+      const hh = readNumber(child, ACTIVITY_PROPERTY.WORK_HOURS);
+      const rw = readChildRealWork(childId, child, hh, adapter);
+      hhSum += hh;
+      rwSum += rw;
+    }
+    adapter.setActivityField(
+      currentParentId,
+      ACTIVITY_PROPERTY.WORK_HOURS,
+      hhSum
+    );
+    adapter.setActivityField(
+      currentParentId,
+      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
+      rwSum
+    );
+    const parentSnap = adapter.getActivity(currentParentId);
+    if (!parentSnap) break;
+    const grandParent = parentSnap.parentId;
+    if (!grandParent || isRootParent(grandParent)) break;
+    currentParentId = grandParent;
+  }
+}
+function recomputeHhCascadeForActivity(activityId, adapter) {
+  const activity = adapter.getActivity(activityId);
+  if (!activity) return;
+  const parentId = activity.parentId;
+  if (!parentId || isRootParent(parentId)) return;
+  recomputeHhCascadeForParent(parentId, adapter);
+}
+function readNumber(activity, key) {
+  const v = activity[key];
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  return 0;
+}
+function readChildRealWork(childId, child, workHours, adapter) {
+  return adapter.hasChildren(childId) ? readNumber(child, ACTIVITY_PROPERTY.REAL_WORK_HOURS) : computeLeafRealWork(
+    workHours,
+    readNumber(child, ACTIVITY_PROPERTY.PROGRESS)
+  );
+}
+
+// src/propagations/upward/recompute-used-cost-cascade.ts
+function recomputeUsedCostCascadeForParent(startParentId, adapter) {
+  if (!startParentId || startParentId === "0") return;
+  let currentParentId = String(startParentId);
+  while (currentParentId !== null) {
+    const childIds = adapter.getChildren(currentParentId);
+    let sum = 0;
+    for (const childId of childIds) {
+      const child = adapter.getActivity(childId);
+      if (!child) continue;
+      sum += readNumber2(child, ACTIVITY_PROPERTY.USED_COST);
+    }
+    adapter.setActivityField(currentParentId, ACTIVITY_PROPERTY.USED_COST, sum);
+    const parentSnap = adapter.getActivity(currentParentId);
+    if (!parentSnap) break;
+    const grandParent = parentSnap.parentId;
+    if (!grandParent || isRootParent(grandParent)) break;
+    currentParentId = grandParent;
+  }
+}
+function recomputeUsedCostCascadeForActivity(activityId, adapter) {
   const activity = adapter.getActivity(activityId);
   if (!activity) return;
   const parentId = activity.parentId;
@@ -10873,27 +10757,6 @@ function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPe
     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);
@@ -12549,17 +12412,524 @@ function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
   for (const candidateId of ids) {
     if (!beforeSnap.has(candidateId)) missing.add(candidateId);
   }
-  if (missing.size === 0) return;
-  for (const [snappedId, snapshot] of snapshotActivities(
+  if (missing.size === 0) return;
+  for (const [snappedId, snapshot] of snapshotActivities(
+    deps.adapter,
+    missing
+  )) {
+    beforeSnap.set(snappedId, snapshot);
+  }
+}
+
+// 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,
-    missing
-  )) {
-    beforeSnap.set(snappedId, snapshot);
+    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);
   }
@@ -15723,6 +16093,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);
+    }
   }
 };
 
@@ -16162,438 +16544,145 @@ var ScheduleState = class {
       this._viewState.restore(this._viewStateBefore);
     }
     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._lastStartDate = this._lastStartDateBefore;
     }
-  });
-}
-
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
+    this._cache.ids = null;
+    this._cache.visualOrderIds = null;
+    this._hierarchy.markDirty();
   }
-}
-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);
+  _restoreCorrelatives(correlativeBefore) {
+    for (const [id, before] of correlativeBefore) {
+      const live = this._activities.get(id);
+      if (live) live.correlativeId = before;
+    }
   }
-  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)
-    });
+  _undoLinkAdds(ops) {
+    for (const op of ops)
+      if (op.kind === "link-add") this._detachLink(op.linkId);
   }
-  const rollup = computeWeightedProgressRollup(children);
-  if (rollup !== null) {
-    adapter.setActivityField(
-      parentId,
-      COLUMN.PROGRESS,
-      roundProgressPerLevel(rollup)
-    );
+  _undoInserts(ops) {
+    for (const op of ops)
+      if (op.kind === "insert") this._activities.delete(op.activityId);
   }
-}
-
-// 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;
+  _reInsertRemovedActivities(ops) {
+    for (const op of ops)
+      if (op.kind === "remove") this._activities.set(op.activityId, 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]);
+  _reAddRemovedLinks(ops) {
+    for (const op of ops)
+      if (op.kind === "link-remove") this._attachLink(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);
+  _restoreLinkFields(ops) {
+    for (const op of ops)
+      if (op.kind === "link-field" && this._links.has(op.linkId))
+        this._links.set(op.linkId, op.before);
   }
-  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);
+  _restoreActivityFields(before) {
+    for (const [id, snapshot] of before) {
+      const live = this._activities.get(id);
+      if (live) this._restoreScalarFields(live, snapshot);
     }
-  });
-  return changed;
+  }
+  _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;
 }
-
-// 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));
-  }
-  return changed;
+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/internal/state/project-work-hours.ts
@@ -16703,8 +16792,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) {
@@ -16971,6 +17064,7 @@ var UndoRecorder = class {
   clear() {
     this.undoStack.length = 0;
     this.redoStack.length = 0;
+    this.resetCoalesce();
   }
 };
 
@@ -18339,6 +18433,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 +18631,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 +18683,7 @@ var ScheduleCore = class {
     return this._status;
   }
   getSector() {
-    return this.coreRuntime.sector;
+    return cloneDomainValue(this.coreRuntime.sector);
   }
   getActivityView(id) {
     this.assertReady();
@@ -18544,7 +18709,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 +18736,7 @@ var ScheduleCore = class {
    */
   getVisualOrderIds() {
     this.assertReady();
-    return this.coreRuntime.state.getVisualOrderIds();
+    return [...this.coreRuntime.state.getVisualOrderIds()];
   }
   hasChild(parentId) {
     this.assertReady();
@@ -18579,15 +18744,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 +18775,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 +18797,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 +18812,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 +18823,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 +18843,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
@@ -18985,12 +18987,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 hasActiveBaseline = false;
+      state.forEachActivity((activity) => {
+        hasActiveBaseline ||= getActiveBaseline(activity) !== null;
+      });
+      if (hasActiveBaseline) {
+        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 +19050,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 +19072,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 +19171,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 +19196,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 +19248,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 +19256,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