@outbuild-company/schedule-core 1.6.0 → 1.6.2

package/dist/index.cjs

@@ -212,19 +212,19 @@ function dispatchSelectionReplace(action, deps) {
 }
 
 // src/dispatch/shared/apply-visible-set.ts
-function applyVisibleSet(adapter, visibleIds) {
+function applyVisibleSet(adapter, visibleIds, activityIds = adapter.getAllIds()) {
   const viewState = [];
-  adapter.forEachActivity((_snapshot, activityId) => {
+  for (const activityId of activityIds) {
     const id = String(activityId);
     const willBeVisible = visibleIds.has(id);
     const before = adapter.isVisible(id);
-    if (before === willBeVisible) return;
+    if (before === willBeVisible) continue;
     adapter.setVisible(id, willBeVisible);
     viewState.push({
       activityId: id,
       visible: { before, after: willBeVisible }
     });
-  });
+  }
   return viewState;
 }
 
@@ -498,6 +498,12 @@ function overlapsRange(activity, range) {
   const windowStartsInside = windowStart >= taskStart && windowStart <= taskEnd;
   return fullyInside || startsInside || windowStartsInside;
 }
+function matchesFilter(activity, filter, context) {
+  const passesCriteria = matchesCriteria(activity, filter, context);
+  const range = filter.dateRange;
+  const passesRange = range === void 0 || overlapsRange(activity, range);
+  return passesCriteria && passesRange;
+}
 function addAncestors(matchedId, parentOf, visibleIds) {
   let ancestorId = parentOf(matchedId);
   while (ancestorId !== null && !visibleIds.has(String(ancestorId))) {
@@ -507,13 +513,10 @@ function addAncestors(matchedId, parentOf, visibleIds) {
 }
 function evaluateVisibleIds(input) {
   const { activities, parentOf, filter, context } = input;
-  const range = filter.dateRange;
   const visibleIds = /* @__PURE__ */ new Set();
   const matchedIds = [];
   for (const activity of activities) {
-    const passesCriteria = matchesCriteria(activity, filter, context);
-    const passesRange = range === void 0 || overlapsRange(activity, range);
-    if (passesCriteria && passesRange) {
+    if (matchesFilter(activity, filter, context)) {
       visibleIds.add(String(activity.id));
       matchedIds.push(activity.id);
     }
@@ -523,6 +526,114 @@ function evaluateVisibleIds(input) {
   }
   return visibleIds;
 }
+function seedFilterProjection(input) {
+  const { activities, parentOf, filter, context } = input;
+  const matchedIds = /* @__PURE__ */ new Set();
+  const pinnedVisibleIds = /* @__PURE__ */ new Set();
+  const visibleReferenceCounts = /* @__PURE__ */ new Map();
+  const parentIds = /* @__PURE__ */ new Map();
+  const remainingChildren = /* @__PURE__ */ new Map();
+  for (const activity of activities) {
+    const activityId = String(activity.id);
+    const parentId = parentOf(activityId);
+    parentIds.set(activityId, parentId);
+    remainingChildren.set(activityId, remainingChildren.get(activityId) ?? 0);
+    if (parentId !== null) {
+      remainingChildren.set(
+        parentId,
+        (remainingChildren.get(parentId) ?? 0) + 1
+      );
+    }
+    const isMatch = matchesFilter(activity, filter, context);
+    const isPinned = input.pinnedVisibleIds?.has(activityId) === true;
+    visibleReferenceCounts.set(
+      activityId,
+      (isMatch ? 1 : 0) + (isPinned ? 1 : 0)
+    );
+    if (isMatch) matchedIds.add(activityId);
+    if (isPinned) pinnedVisibleIds.add(activityId);
+  }
+  return {
+    matchedIds,
+    pinnedVisibleIds,
+    visibleReferenceCounts,
+    parentIds,
+    remainingChildren
+  };
+}
+function propagateVisibleReferenceCounts(seed2) {
+  const { visibleReferenceCounts, parentIds, remainingChildren } = seed2;
+  const pendingIds = [];
+  for (const activityId of parentIds.keys()) {
+    if (remainingChildren.get(activityId) === 0) pendingIds.push(activityId);
+  }
+  while (pendingIds.length > 0) {
+    const activityId = pendingIds.pop();
+    if (activityId === void 0) break;
+    const parentId = parentIds.get(activityId);
+    if (parentId === null || parentId === void 0) continue;
+    const referenceCount = visibleReferenceCounts.get(activityId) ?? 0;
+    visibleReferenceCounts.set(
+      parentId,
+      (visibleReferenceCounts.get(parentId) ?? 0) + referenceCount
+    );
+    const remaining = (remainingChildren.get(parentId) ?? 1) - 1;
+    remainingChildren.set(parentId, remaining);
+    if (remaining === 0) pendingIds.push(parentId);
+  }
+}
+function collectVisibleIds(visibleReferenceCounts) {
+  const visibleIds = /* @__PURE__ */ new Set();
+  for (const [activityId, referenceCount] of visibleReferenceCounts) {
+    if (referenceCount > 0) visibleIds.add(activityId);
+  }
+  return visibleIds;
+}
+function buildFilterProjection(input) {
+  const seed2 = seedFilterProjection(input);
+  propagateVisibleReferenceCounts(seed2);
+  const visibleIds = collectVisibleIds(seed2.visibleReferenceCounts);
+  return {
+    filter: input.filter,
+    context: input.context,
+    matchedIds: seed2.matchedIds,
+    pinnedVisibleIds: seed2.pinnedVisibleIds,
+    visibleIds,
+    visibleReferenceCounts: seed2.visibleReferenceCounts
+  };
+}
+function updateFilterProjection(projection, activities, parentOf) {
+  const changedVisibilityIds = /* @__PURE__ */ new Set();
+  for (const activity of activities) {
+    const activityId = String(activity.id);
+    changedVisibilityIds.add(activityId);
+    const wasMatch = projection.matchedIds.has(activityId);
+    const isMatch = matchesFilter(
+      activity,
+      projection.filter,
+      projection.context
+    );
+    if (wasMatch === isMatch) continue;
+    if (isMatch) projection.matchedIds.add(activityId);
+    else projection.matchedIds.delete(activityId);
+    const referenceDelta = isMatch ? 1 : -1;
+    let currentId = activityId;
+    while (currentId !== null) {
+      const beforeCount = projection.visibleReferenceCounts.get(currentId) ?? 0;
+      const afterCount = beforeCount + referenceDelta;
+      projection.visibleReferenceCounts.set(currentId, afterCount);
+      const wasVisible = beforeCount > 0;
+      const isVisible = afterCount > 0;
+      if (wasVisible !== isVisible) {
+        changedVisibilityIds.add(currentId);
+        if (isVisible) projection.visibleIds.add(currentId);
+        else projection.visibleIds.delete(currentId);
+      }
+      currentId = parentOf(currentId);
+    }
+  }
+  return changedVisibilityIds;
+}
 
 // src/internal/filter/context.ts
 var COLLATION_LOCALE = "en";
@@ -583,17 +694,26 @@ function isValidDateValue(value) {
 function isEmptyFilter(filter) {
   return filter.criteria.length === 0 && filter.dateRange === void 0;
 }
-function resolveVisibleIds(adapter, filter, hoursPerDay) {
+function resolveFilter(adapter, filter, hoursPerDay) {
   const activities = adapter.getAllActivities();
   if (isEmptyFilter(filter)) {
-    return new Set(activities.map((activity) => String(activity.id)));
+    return {
+      visibleIds: evaluateVisibleIds({
+        activities,
+        parentOf: (activityId) => adapter.getParentId(activityId),
+        filter,
+        context: buildFilterContext(hoursPerDay)
+      }),
+      projection: null
+    };
   }
-  return evaluateVisibleIds({
+  const projection = buildFilterProjection({
     activities,
     parentOf: (activityId) => adapter.getParentId(activityId),
     filter,
     context: buildFilterContext(hoursPerDay)
   });
+  return { visibleIds: projection.visibleIds, projection };
 }
 function dispatchFilterSet(action, deps) {
   const { adapter, hoursPerDay } = deps;
@@ -607,7 +727,12 @@ function dispatchFilterSet(action, deps) {
     dateRange: action.dateRange
   };
   adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
-  const visibleIds = resolveVisibleIds(adapter, filter, hoursPerDay);
+  const { visibleIds, projection } = resolveFilter(
+    adapter,
+    filter,
+    hoursPerDay
+  );
+  adapter.setFilterProjection(projection);
   const viewState = applyVisibleSet(adapter, visibleIds);
   const changes = {
     source: action,
@@ -678,11 +803,7 @@ function visualIndexInParent(taskId, adapter) {
   return siblings.findIndex((id) => String(id) === String(taskId));
 }
 function collectChildrenSnapshots(parentId, adapter) {
-  const key = String(parentId);
-  if (key === "0") {
-    return adapter.getAllActivities().filter((a) => a.parentId === null);
-  }
-  const childIds = adapter.getChildren(parentId);
+  const childIds = String(parentId) === ROOT_PARENT_ID ? adapter.getRootIds?.() ?? adapter.getChildren(ROOT_PARENT_ID) : adapter.getChildren(parentId);
   const out = [];
   for (const id of childIds) {
     const snap = adapter.getActivity(id);
@@ -726,6 +847,14 @@ function collectBranchOrder(adapter) {
   visit(ROOT_PARENT_ID);
   return branches;
 }
+function collectBranchOrderForParents(adapter, parentIds) {
+  const branches = [];
+  for (const parentId of parentIds) {
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    if (childIds.length > 1) branches.push({ parentId, childIds });
+  }
+  return branches;
+}
 
 // src/dispatch/order.ts
 function validateRule(rule) {
@@ -2277,6 +2406,34 @@ function wouldIntroduceCycle(existingLinks, proposedLink) {
   }
   return hasPath(adjacency, tgt, src);
 }
+function hasDirectedCycle(links) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const indegrees = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const source = String(link.source);
+    const target = String(link.target);
+    const neighbors = adjacency.get(source) ?? [];
+    neighbors.push(target);
+    adjacency.set(source, neighbors);
+    indegrees.set(source, indegrees.get(source) ?? 0);
+    indegrees.set(target, (indegrees.get(target) ?? 0) + 1);
+  }
+  const ready = new Queue();
+  for (const [activityId, indegree] of indegrees) {
+    if (indegree === 0) ready.enqueue(activityId);
+  }
+  let visited = 0;
+  while (!ready.isEmpty()) {
+    const current = ready.dequeue();
+    visited += 1;
+    for (const neighbor of adjacency.get(current) ?? []) {
+      const indegree = indegrees.get(neighbor) - 1;
+      indegrees.set(neighbor, indegree);
+      if (indegree === 0) ready.enqueue(neighbor);
+    }
+  }
+  return visited !== indegrees.size;
+}
 function hasPath(adjacency, from, to) {
   if (from === to) return true;
   const visited = /* @__PURE__ */ new Set([from]);
@@ -2306,6 +2463,70 @@ function applyLinkOperation(op, deps) {
       return applyDelete(op, deps);
   }
 }
+function applyLinkCreates(links, deps) {
+  if (links.length === 0) return { applied: true };
+  const existingLinks = deps.port.getAllLinks();
+  const duplicateKeys = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const link of existingLinks) {
+    const key = linkKey(link);
+    if (!duplicateKeys.has(key)) duplicateKeys.set(key, link.id);
+    edges.push({ source: link.source, target: link.target });
+  }
+  const existingGraphHasCycle = hasDirectedCycle(edges);
+  let rejected = null;
+  for (const { operation, linkId } of links) {
+    if (String(operation.source) === String(operation.target)) {
+      rejected = { applied: false, rejected: "self-link" };
+      break;
+    }
+    if (!deps.port.getActivity(operation.source) || !deps.port.getActivity(operation.target)) {
+      rejected = { applied: false, rejected: "activity-missing" };
+      break;
+    }
+    const key = linkKey(operation);
+    const duplicateId = duplicateKeys.get(key);
+    if (duplicateId !== void 0) {
+      rejected = {
+        applied: false,
+        rejected: "duplicate",
+        linkId: duplicateId
+      };
+      break;
+    }
+    duplicateKeys.set(key, linkId);
+    if (existingGraphHasCycle && // ponytail: preserve legacy sequential semantics; optimize with dynamic
+    // SCC reachability only if corrupt cyclic schedules become measurable.
+    wouldIntroduceCycle(edges, {
+      source: operation.source,
+      target: operation.target
+    })) {
+      return { applied: false, rejected: "cycle" };
+    }
+    edges.push({ source: operation.source, target: operation.target });
+  }
+  if (!existingGraphHasCycle && hasDirectedCycle(edges)) {
+    return { applied: false, rejected: "cycle" };
+  }
+  if (rejected) return rejected;
+  for (const { operation, linkId } of links) {
+    const preserved = deps.preserved?.get(linkId);
+    deps.port.addLink({
+      id: linkId,
+      source: operation.source,
+      target: operation.target,
+      type: operation.type,
+      lag: operation.lag,
+      ...preserved?.ganttId === void 0 ? {} : { ganttId: preserved.ganttId },
+      ...preserved?.sectorId === void 0 ? {} : { sectorId: preserved.sectorId },
+      ...preserved?.proplannerId === void 0 ? {} : { proplannerId: preserved.proplannerId }
+    });
+  }
+  return { applied: true };
+}
+function linkKey(link) {
+  return JSON.stringify([String(link.source), String(link.target), link.type]);
+}
 function applyCreate(op, deps) {
   const { port } = deps;
   if (String(op.source) === String(op.target)) {
@@ -2429,14 +2650,14 @@ function diffLinks(input) {
       unresolved.push(spec);
       continue;
     }
-    const key = linkKey(source, spec.type);
+    const key = linkKey2(source, spec.type);
     if (desired.has(key)) continue;
     desired.set(key, { source, type: spec.type, lag: spec.lag });
   }
   const currentByKey = /* @__PURE__ */ new Map();
   for (const link of currentLinks) {
     if (String(link.target) !== String(targetActivityId)) continue;
-    currentByKey.set(linkKey(link.source, link.type), link);
+    currentByKey.set(linkKey2(link.source, link.type), link);
   }
   const operations = [];
   for (const [key, link] of currentByKey) {
@@ -2463,7 +2684,7 @@ function diffLinks(input) {
   }
   return { operations, unresolved };
 }
-function linkKey(source, type) {
+function linkKey2(source, type) {
   return `${String(source)}::${type}`;
 }
 function diffOutgoingLinks(input) {
@@ -2476,14 +2697,14 @@ function diffOutgoingLinks(input) {
       unresolved.push(spec);
       continue;
     }
-    const key = linkKey(target, spec.type);
+    const key = linkKey2(target, spec.type);
     if (desired.has(key)) continue;
     desired.set(key, { target, type: spec.type, lag: spec.lag });
   }
   const currentByKey = /* @__PURE__ */ new Map();
   for (const link of currentLinks) {
     if (String(link.source) !== String(sourceActivityId)) continue;
-    currentByKey.set(linkKey(link.target, link.type), link);
+    currentByKey.set(linkKey2(link.target, link.type), link);
   }
   const operations = [];
   for (const [key, link] of currentByKey) {
@@ -5550,7 +5771,7 @@ var CalculateBackwardParentsLinks = class {
       return false;
     }
     return allLinksCalculations.reduce(
-      (min, activity) => activity.lf < min.lf ? activity : min
+      (min2, activity) => activity.lf < min2.lf ? activity : min2
     );
   }
   calculateSfRestrictionDates() {
@@ -7723,13 +7944,13 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
   getMinDateFromLinks(allLinksCalculations) {
     try {
       if (this.constraint === CONSTRAINT_TYPES.ALAP || this.constraint === CONSTRAINT_TYPES.ASAP) {
-        const min = allLinksCalculations.reduce(
-          (min2, activity) => activity.lf < min2.lf ? activity : min2
+        const min2 = allLinksCalculations.reduce(
+          (min3, activity) => activity.lf < min3.lf ? activity : min3
         );
-        return min;
+        return min2;
       }
       return allLinksCalculations.reduce(
-        (min, activity) => activity.ls < min.ls ? activity : min
+        (min2, activity) => activity.ls < min2.ls ? activity : min2
       );
     } catch (error) {
       throw new Error(
@@ -7739,7 +7960,7 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
   }
   getMinLfFromLinks(allLinksCalculations) {
     return allLinksCalculations.reduce(
-      (min, activity) => activity.lf < min.lf ? activity : min
+      (min2, activity) => activity.lf < min2.lf ? activity : min2
     );
   }
   getMinDateBasedOnConstraint(minCalculatedDateFromLinks, constraintType = this.constraint) {
@@ -8197,7 +8418,7 @@ var BackwardPath = class extends generic_calculations_default {
       return false;
     }
     return allLinksCalculations.reduce(
-      (min, activity) => activity.lf < min.lf ? activity : min
+      (min2, activity) => activity.lf < min2.lf ? activity : min2
     );
   }
 };
@@ -8796,7 +9017,7 @@ var CriticalPath = class {
           activitiesCount: this.forwardPathCalculations?.size || 0
         }
       });
-      return false;
+      throw error;
     }
   }
   async calculateFloatsAsync(forward, backward, isCurrent) {
@@ -8817,7 +9038,7 @@ var CriticalPath = class {
           activitiesCount: this.forwardPathCalculations?.size || 0
         }
       });
-      return { totalFloatMap: /* @__PURE__ */ new Map(), freeFloatMap: /* @__PURE__ */ new Map() };
+      throw error;
     }
   }
 };
@@ -8842,16 +9063,41 @@ function constraintDateForCriticalPath(activity, state) {
   return typedDayIsWorking ? getEffectiveConstraintDate(activity, state) : raw;
 }
 function toLegacyCalendar(api) {
+  const endDateByKey = /* @__PURE__ */ new Map();
+  const durationByKey = /* @__PURE__ */ new Map();
+  const closestWorkTimeByKey = /* @__PURE__ */ new Map();
   return {
-    calculateEndDate: ({ start_date, duration }) => api.calculateEndDate(start_date, duration),
-    calculateDuration: ({ start_date, end_date }) => api.calculateDuration(start_date, end_date),
+    calculateEndDate: ({ start_date, duration }) => {
+      const key = `${start_date.getTime()}|${duration}`;
+      const cached = endDateByKey.get(key);
+      if (cached !== void 0) return new Date(cached);
+      const value = api.calculateEndDate(start_date, duration);
+      endDateByKey.set(key, value.getTime());
+      return value;
+    },
+    calculateDuration: ({ start_date, end_date }) => {
+      const key = `${start_date.getTime()}|${end_date.getTime()}`;
+      const cached = durationByKey.get(key);
+      if (cached !== void 0) return cached;
+      const value = api.calculateDuration(start_date, end_date);
+      durationByKey.set(key, value);
+      return value;
+    },
     getWorkHours: (date2) => api.getWorkHours(date2),
     $gantt: {
-      getClosestWorkTime: ({ date: date2, dir, unit }) => api.getClosestWorkTime({
-        date: date2,
-        direction: dir,
-        unit: unit ?? "hour"
-      })
+      getClosestWorkTime: ({ date: date2, dir, unit }) => {
+        const resolvedUnit = unit ?? "hour";
+        const key = `${date2.getTime()}|${dir}|${resolvedUnit}`;
+        const cached = closestWorkTimeByKey.get(key);
+        if (cached !== void 0) return new Date(cached);
+        const value = api.getClosestWorkTime({
+          date: date2,
+          direction: dir,
+          unit: resolvedUnit
+        });
+        closestWorkTimeByKey.set(key, value.getTime());
+        return value;
+      }
     }
   };
 }
@@ -8931,19 +9177,19 @@ function orderByTree(leveled) {
   return ordered;
 }
 function projectBounds(state) {
-  let min = null;
-  let max = null;
+  let min2 = null;
+  let max2 = null;
   state.forEachActivity((activity) => {
     if (activity.startDate) {
       const start = activity.startDate.getTime();
-      min = min == null ? start : Math.min(min, start);
+      min2 = min2 == null ? start : Math.min(min2, start);
     }
     if (activity.endDate) {
       const end = activity.endDate.getTime();
-      max = max == null ? end : Math.max(max, end);
+      max2 = max2 == null ? end : Math.max(max2, end);
     }
   });
-  return { start_date: new Date(min ?? 0), end_date: new Date(max ?? 0) };
+  return { start_date: new Date(min2 ?? 0), end_date: new Date(max2 ?? 0) };
 }
 async function createGanttAdapter(state, hoursPerDay) {
   const calendarCache = /* @__PURE__ */ new Map();
@@ -9010,13 +9256,27 @@ function fieldsForActivity(activityId, progress, maps) {
     freeSlackHours: maps.freeFloat.get(activityId)?.activityFreeFloat ?? null
   };
 }
+var datesEqual = (left, right) => left === right || left !== null && right !== null && left.getTime() === right.getTime();
+function setCriticalPathFieldsIfChanged(state, activityId, fields) {
+  const activity = state.getActivity(activityId);
+  const current = activity?.criticalPath;
+  const next = fields.criticalPath;
+  if (activity && current && datesEqual(current.earlyStart, next.earlyStart) && datesEqual(current.earlyFinish, next.earlyFinish) && datesEqual(current.lateStart, next.lateStart) && datesEqual(current.lateFinish, next.lateFinish) && Object.is(current.totalSlackHours, next.totalSlackHours) && Object.is(activity.isCritical, fields.isCritical) && Object.is(activity.freeSlackHours, fields.freeSlackHours)) {
+    return;
+  }
+  state.setActivityFields(activityId, fields);
+}
 async function computeCriticalPathFields(state, hoursPerDay, isCurrent = () => true) {
   if (!isCurrent()) return null;
   const gantt = await createGanttAdapter(state, hoursPerDay);
   if (!isCurrent()) return null;
   const criticalPath = new legacy_default(gantt);
   const calculated = await criticalPath.calculate(gantt, isCurrent);
-  if (!calculated || !isCurrent()) return null;
+  if (!calculated) {
+    if (!isCurrent()) return null;
+    throw new Error("critical path calculation aborted");
+  }
+  if (!isCurrent()) return null;
   const maps = {
     forward: criticalPath.forwardPathCalculations,
     backward: criticalPath.backwardPathCalculations,
@@ -9051,7 +9311,7 @@ async function applyCriticalPath(state, hoursPerDay, isCurrent = () => true) {
   if (!fieldsByActivity || !isCurrent()) return false;
   for (const [activityId, fields] of fieldsByActivity) {
     if (!isCurrent()) return false;
-    state.setActivityFields(activityId, fields);
+    setCriticalPathFieldsIfChanged(state, activityId, fields);
   }
   return true;
 }
@@ -9528,6 +9788,40 @@ function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
       if (!finalLinkId) continue;
       const after = adapter.getLink(finalLinkId);
       if (!after) continue;
+      const before = beforeLinks.get(finalLinkId);
+      if (before) {
+        const fields2 = {};
+        if (String(before.source) !== String(after.source)) {
+          fields2.source = {
+            before: String(before.source),
+            after: String(after.source)
+          };
+        }
+        if (String(before.target) !== String(after.target)) {
+          fields2.target = {
+            before: String(before.target),
+            after: String(after.target)
+          };
+        }
+        if (before.type !== after.type) {
+          fields2.type = { before: before.type, after: after.type };
+        }
+        if (Number(before.lag) !== Number(after.lag)) {
+          fields2.lag = {
+            before: Number(before.lag),
+            after: Number(after.lag)
+          };
+        }
+        if (Object.keys(fields2).length > 0) {
+          out.push({
+            id: String(finalLinkId),
+            kind: "updated",
+            fields: fields2,
+            after: snapshotToLink(after)
+          });
+        }
+        continue;
+      }
       out.push({
         id: String(finalLinkId),
         kind: "created",
@@ -9542,6 +9836,7 @@ function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
       continue;
     }
     if (op.kind === "delete") {
+      if (adapter.getLink(op.linkId)) continue;
       const beforeLink2 = beforeLinks.get(op.linkId);
       out.push({
         id: String(op.linkId),
@@ -10378,8 +10673,8 @@ function computeInsertionCorrelativeId(adapter, parentId, afterSiblingId, before
     }
   }
   if (siblings.length === 0) return isRoot ? 0 : 0;
-  const max = Math.max(...siblings.map(readCorrelativeId));
-  return max + 1;
+  const max2 = Math.max(...siblings.map(readCorrelativeId));
+  return max2 + 1;
 }
 var NOT_SET_SORT_VALUE2 = Number.MAX_SAFE_INTEGER;
 var TEMP_CID_SENTINEL = Number.MAX_SAFE_INTEGER - 1;
@@ -10389,12 +10684,7 @@ function readCorrelativeId(activity) {
   return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE2;
 }
 function collectSiblings(adapter, parentKey) {
-  const siblings = [];
-  adapter.forEachActivity((a) => {
-    const ap = normalizeParentKey(a.parentId);
-    if (ap === parentKey) siblings.push(a);
-  });
-  return siblings;
+  return collectChildrenSnapshots(parentKey, adapter);
 }
 function findFirstSelectedSibling(taskId, selected, adapter) {
   let firstSelected = taskId;
@@ -10444,7 +10734,7 @@ function computeFractionalCidAtIndex(adapter, parentKey, targetIndex, excludeId)
 // src/dispatch/handlers/activity-create.ts
 async function createActivityCore(action, deps, opts = {}) {
   const { adapter, scheduler, sector, calendars, activityIdGen, uidGen } = deps;
-  scheduler.invalidateAllCaches();
+  if (!opts.skipCacheInvalidation) scheduler.invalidateAllCaches();
   const target = validateCreateTarget(action, adapter);
   if (!target.ok) return target;
   const { parent, anchorSiblingId, isRoot } = target;
@@ -10473,7 +10763,7 @@ async function createActivityCore(action, deps, opts = {}) {
     newActivity.progress
   );
   assignCustomId(newActivity, action, deps, anchorSiblingId, parent, opts);
-  const insertionCorrelativeId = computeInsertionCorrelativeId(
+  const insertionCorrelativeId = opts.insertionCorrelativeId ?? computeInsertionCorrelativeId(
     adapter,
     isRoot ? ROOT_PARENT_ID : action.parentId,
     action.afterSiblingId,
@@ -10483,12 +10773,18 @@ async function createActivityCore(action, deps, opts = {}) {
   const initialTouched = /* @__PURE__ */ new Set([newId]);
   if (parent) initialTouched.add(parent.id);
   const parentWasLeaf = parent !== null && adapter.getChildren(parent.id).length === 0;
+  const parentCustomId = parentWasLeaf ? parent?.customId : null;
   const beforeSnap = opts.skipBeforeSnap ? /* @__PURE__ */ new Map() : await snapshotActivities(adapter, initialTouched);
   adapter.addActivity(newActivity);
   applyParentMutations(action, newId, parent, adapter, parentWasLeaf);
-  recomputeHhCascadeForActivity(newId, adapter);
-  recomputeUsedCostCascadeForActivity(newId, adapter);
-  recomputeCostCascadeForActivity(newId, adapter);
+  if (parentCustomId) {
+    deps.customIdTracker.releaseCustomId(parentCustomId);
+  }
+  if (!opts.skipRollupCascades) {
+    recomputeHhCascadeForActivity(newId, adapter);
+    recomputeUsedCostCascadeForActivity(newId, adapter);
+    recomputeCostCascadeForActivity(newId, adapter);
+  }
   recomputeAndFoldCorrelatives(
     adapter,
     newId,
@@ -10660,330 +10956,96 @@ function findDefaultCalendarId(calendars) {
   return "global";
 }
 
-// src/dispatch/handlers/activity-paste.ts
-function resolvePasteRootDestination(destination, adapter) {
-  if ("afterSiblingId" in destination) {
-    const sibling = adapter.getActivity(destination.afterSiblingId);
-    if (!sibling) {
-      return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
+// src/propagations/upward/recompute-rollup-cascades.ts
+function recomputeRollupCascadesForParent(parentId, adapter) {
+  recomputeHhCascadeForParent(parentId, adapter);
+  recomputeUsedCostCascadeForParent(parentId, adapter);
+  recomputeCostCascadeForParent(parentId, adapter);
+}
+
+// src/propagations/shared/traversal-helpers.ts
+function collectDescendantIds(rootIds, adapter) {
+  const out = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const id of rootIds) {
+    const key = String(id);
+    if (!out.has(key)) {
+      out.add(key);
+      stack.push(key);
     }
-    const parentId2 = sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId);
-    return { ok: true, parentId: parentId2, firstAfter: destination.afterSiblingId };
   }
-  const parentId = destination.parentId;
-  const siblings = collectSiblings(adapter, parentId).sort(
-    (a, b) => readCorrelativeId(a) - readCorrelativeId(b)
-  );
-  const before = siblings[destination.index]?.id;
-  return { ok: true, parentId, firstBefore: before };
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const children = adapter.getChildren(current);
+    for (const childId of children) {
+      const key = String(childId);
+      if (!out.has(key)) {
+        out.add(key);
+        stack.push(key);
+      }
+    }
+  }
+  return out;
 }
-function applyPasteDomainSemantics(overrides) {
-  const { customId: _customId, ...content } = overrides;
+function collectIncidentLinkIds(activityIds, adapter) {
+  const out = /* @__PURE__ */ new Set();
+  for (const activityId of activityIds) {
+    for (const linkId of adapter.getOutgoingLinkIds(activityId)) {
+      out.add(String(linkId));
+    }
+    for (const linkId of adapter.getIncomingLinkIds(activityId)) {
+      out.add(String(linkId));
+    }
+  }
+  return [...out];
+}
+
+// src/internal/hierarchy/parent-demotion.ts
+function restoredPromotionFields(restore) {
+  if (!restore) return null;
   return {
-    ...content,
-    progress: 0,
-    ponderator: 0,
-    usedCost: 0,
-    workHours: 0,
-    isLookahead: false
+    type: restore.type,
+    startDate: new Date(restore.startDate),
+    endDate: new Date(restore.endDate),
+    durationHours: restore.durationHours,
+    expectedProgressBaseline: restore.expectedProgressBaseline,
+    constraintType: restore.constraintType,
+    constraintDate: restore.constraintDate ? new Date(restore.constraintDate) : null,
+    progress: restore.progress
   };
 }
-async function dispatchActivityPaste(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  const rootDest = resolvePasteRootDestination(action.destination, adapter);
-  if (!rootDest.ok) return rootDest;
-  const beforeSnap = await snapshotActivities(adapter, /* @__PURE__ */ new Set());
-  const touched = /* @__PURE__ */ new Set();
-  const originalToNew = /* @__PURE__ */ new Map();
-  const createdIds = [];
-  let prevRootId;
-  for (const input of action.activities) {
-    const mappedParent = originalToNew.get(input.originalParentId);
-    let parentId;
-    let afterSiblingId;
-    let beforeSiblingId;
-    if (mappedParent !== void 0) {
-      parentId = mappedParent;
-    } else {
-      parentId = rootDest.parentId;
-      if (prevRootId === void 0) {
-        afterSiblingId = rootDest.firstAfter;
-        beforeSiblingId = rootDest.firstBefore;
-      } else {
-        afterSiblingId = prevRootId;
-      }
-    }
-    const core = await createActivityCore(
-      {
-        parentId,
-        afterSiblingId,
-        beforeSiblingId,
-        ...input.activityId ? { activityId: input.activityId } : {},
-        overrides: applyPasteDomainSemantics(input.overrides),
-        eventSource: action.eventSource
-      },
-      deps,
-      {
-        skipCorrelativeRecompute: true,
-        skipBeforeSnap: true,
-        customIdReferenceId: action.referenceActivityId
-      }
-    );
-    if (!core.ok) return core;
-    if (input.baselineSnapshot !== void 0) {
-      const snapshot = input.baselineSnapshot;
-      adapter.setActivityField(
-        core.newId,
-        "baselineSnapshot",
-        snapshot ? {
-          ...snapshot,
-          startDate: snapshot.startDate ? new Date(snapshot.startDate) : null,
-          endDate: snapshot.endDate ? new Date(snapshot.endDate) : null
-        } : null
-      );
-    }
-    originalToNew.set(input.originalId, core.newId);
-    createdIds.push(core.newId);
-    if (mappedParent === void 0) prevRootId = core.newId;
-  }
-  const correlativeShifts = recomputeCorrelativeIds(adapter);
-  const createdIdSet = new Set(createdIds.map(String));
-  foldCorrelativeShifts(
-    adapter,
-    correlativeShifts,
-    createdIdSet,
-    beforeSnap,
-    touched
-  );
-  for (const createdId of createdIds) touched.add(String(createdId));
-  const appliedLinks = [];
-  for (const link of action.links) {
-    const newSource = originalToNew.get(link.source);
-    const newTarget = originalToNew.get(link.target);
-    if (newSource === void 0 || newTarget === void 0) continue;
-    const op = {
-      kind: "create",
-      source: newSource,
-      target: newTarget,
-      type: link.type,
-      lag: lagDaysToHours(link.lag, sector.hoursPerDay)
-    };
-    const res = applyLinkOperation(op, {
-      port: adapter,
-      newLinkId: link.linkId ? () => link.linkId : deps.linkIdGen.next
-    });
-    appliedLinks.push({
-      op,
-      finalLinkId: res.applied ? res.linkId : null,
-      rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
-    });
-  }
-  const { scheduledIds } = await runPostMutation(
-    {
-      adapter,
-      scheduler,
-      sector: deps.sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    {
-      action,
-      autoscheduleFrom: createdIds[0] ?? null,
-      recomputeParentsFrom: createdIds,
-      now: deps.now,
-      options
-    }
-  );
-  const linkChanges = buildLinkChangesForBatch(
-    appliedLinks,
-    /* @__PURE__ */ new Map(),
-    adapter
-  );
-  return {
-    ok: true,
-    changes: await assembleChangeSet(adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds: touched,
-      scheduledIds,
-      links: linkChanges,
-      hoursPerDay: sector.hoursPerDay
-    })
-  };
-}
-
-// src/dispatch/handlers/sir-sync.ts
-function dispatchSirSync(action, deps) {
-  const { adapter } = deps;
-  const id = action.activityId;
-  const snapshot = adapter.getActivity(id);
-  if (!snapshot) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
-  }
-  const before = snapshot.pendingRequestIds ?? [];
-  const after = action.pendingRequests.map((r) => r.id);
-  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
-  const change = {
-    id,
-    kind: "updated",
-    fields: { pendingRequestIds: { before, after } },
-    after: { id, pendingRequestIds: after }
-  };
-  return {
-    ok: true,
-    changes: {
-      source: action,
-      activities: [change],
-      links: [],
-      calendars: [],
-      trackingEvents: []
-    }
-  };
-}
-
-// src/dispatch/handlers/activity-lookahead-sync.ts
-function dispatchActivityLookaheadSync(action, deps) {
-  const ids = [...new Set(action.activityIds.map(String))];
-  const snapshots = ids.map((id) => deps.adapter.getActivity(id));
-  if (snapshots.some((snapshot) => !snapshot)) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
-  }
-  const activities = [];
-  for (const [index, id] of ids.entries()) {
-    const snapshot = snapshots[index];
-    if (!snapshot) continue;
-    const fields = {};
-    if (snapshot.isLookahead !== action.isLookahead) {
-      fields.isLookahead = {
-        before: snapshot.isLookahead,
-        after: action.isLookahead
-      };
-      deps.adapter.setActivityField(id, "isLookahead", action.isLookahead);
-    }
-    if (snapshot.hasLookaheadTasks !== action.hasLookaheadTasks) {
-      fields.hasLookaheadTasks = {
-        before: snapshot.hasLookaheadTasks,
-        after: action.hasLookaheadTasks
-      };
-      deps.adapter.setActivityField(
-        id,
-        "hasLookaheadTasks",
-        action.hasLookaheadTasks
-      );
-    }
-    if (Object.keys(fields).length === 0) continue;
-    activities.push({
-      id,
-      kind: "updated",
-      fields,
-      after: {
-        ...snapshot,
-        isLookahead: action.isLookahead,
-        hasLookaheadTasks: action.hasLookaheadTasks
-      }
-    });
-  }
-  return {
-    ok: true,
-    changes: {
-      source: action,
-      activities,
-      links: [],
-      calendars: [],
-      trackingEvents: []
-    }
-  };
-}
-
-// src/propagations/upward/recompute-rollup-cascades.ts
-function recomputeRollupCascadesForParent(parentId, adapter) {
-  recomputeHhCascadeForParent(parentId, adapter);
-  recomputeUsedCostCascadeForParent(parentId, adapter);
-  recomputeCostCascadeForParent(parentId, adapter);
-}
-
-// src/propagations/shared/traversal-helpers.ts
-function collectDescendantIds(rootIds, adapter) {
-  const out = /* @__PURE__ */ new Set();
-  const stack = [];
-  for (const id of rootIds) {
-    const key = String(id);
-    if (!out.has(key)) {
-      out.add(key);
-      stack.push(key);
-    }
-  }
-  while (stack.length > 0) {
-    const current = stack.pop();
-    const children = adapter.getChildren(current);
-    for (const childId of children) {
-      const key = String(childId);
-      if (!out.has(key)) {
-        out.add(key);
-        stack.push(key);
-      }
-    }
-  }
-  return out;
-}
-function collectIncidentLinkIds(activityIds, adapter) {
-  const out = /* @__PURE__ */ new Set();
-  for (const activityId of activityIds) {
-    for (const linkId of adapter.getOutgoingLinkIds(activityId)) {
-      out.add(String(linkId));
-    }
-    for (const linkId of adapter.getIncomingLinkIds(activityId)) {
-      out.add(String(linkId));
-    }
-  }
-  return [...out];
-}
-
-// src/internal/hierarchy/parent-demotion.ts
-function restoredPromotionFields(restore) {
-  if (!restore) return null;
-  return {
-    type: restore.type,
-    startDate: new Date(restore.startDate),
-    endDate: new Date(restore.endDate),
-    durationHours: restore.durationHours,
-    expectedProgressBaseline: restore.expectedProgressBaseline,
-    constraintType: restore.constraintType,
-    constraintDate: restore.constraintDate ? new Date(restore.constraintDate) : null,
-    progress: restore.progress
-  };
-}
-function canonicalEndDateField(parent, durationHours, computeEndDate) {
-  const startDate = parent.startDate;
-  if (!computeEndDate || !(startDate instanceof Date)) return {};
-  return { endDate: computeEndDate(startDate, durationHours) };
-}
-function buildParentDemotionMutations(input) {
-  if (input.remainingChildIds.length > 0) return null;
-  const parent = input.parent;
-  const canonicalDuration = input.defaultDurationHours;
-  const hasCanonicalDefaults = Number.isFinite(canonicalDuration);
-  const fields = restoredPromotionFields(input.promotionSnapshot) ?? (hasCanonicalDefaults ? {
-    type: DEMOTION_TARGET_TYPE,
-    durationHours: canonicalDuration,
-    progress: 0,
-    autoScheduling: true,
-    constraintType: "asap",
-    constraintDate: null,
-    hasNewActivities: false,
-    ...canonicalEndDateField(
-      parent,
-      canonicalDuration,
-      input.computeEndDate
-    )
-  } : { type: DEMOTION_TARGET_TYPE });
-  if (input.idsRemoved && input.idsRemoved.size > 0) {
-    const existing = Array.isArray(parent.newActivityIds) ? parent.newActivityIds : [];
-    if (existing.length > 0) {
-      const filtered = existing.filter(
-        (id) => !input.idsRemoved.has(id) && !input.idsRemoved.has(String(id))
-      );
-      if (filtered.length !== existing.length) {
-        fields.newActivityIds = filtered;
+function canonicalEndDateField(parent, durationHours, computeEndDate) {
+  const startDate = parent.startDate;
+  if (!computeEndDate || !(startDate instanceof Date)) return {};
+  return { endDate: computeEndDate(startDate, durationHours) };
+}
+function buildParentDemotionMutations(input) {
+  if (input.remainingChildIds.length > 0) return null;
+  const parent = input.parent;
+  const canonicalDuration = input.defaultDurationHours;
+  const hasCanonicalDefaults = Number.isFinite(canonicalDuration);
+  const fields = restoredPromotionFields(input.promotionSnapshot) ?? (hasCanonicalDefaults ? {
+    type: DEMOTION_TARGET_TYPE,
+    durationHours: canonicalDuration,
+    progress: 0,
+    autoScheduling: true,
+    constraintType: "asap",
+    constraintDate: null,
+    hasNewActivities: false,
+    ...canonicalEndDateField(
+      parent,
+      canonicalDuration,
+      input.computeEndDate
+    )
+  } : { type: DEMOTION_TARGET_TYPE });
+  if (input.idsRemoved && input.idsRemoved.size > 0) {
+    const existing = Array.isArray(parent.newActivityIds) ? parent.newActivityIds : [];
+    if (existing.length > 0) {
+      const filtered = existing.filter(
+        (id) => !input.idsRemoved.has(id) && !input.idsRemoved.has(String(id))
+      );
+      if (filtered.length !== existing.length) {
+        fields.newActivityIds = filtered;
       }
     }
   }
@@ -11192,7 +11254,647 @@ function buildLinkDeletions(beforeLinks) {
       after: null
     });
   }
-  return out;
+  return out;
+}
+
+// src/dispatch/handlers/activity-batch.ts
+async function dispatchActivityBatch(action, options, deps) {
+  const validationError = validateBatch(action, deps);
+  if (validationError) return { ok: false, reason: validationError };
+  const plan = buildBatchPlan(action, deps);
+  if (!plan.ok) return plan;
+  const existingActivityIds = action.mode === "replace" ? new Set(deps.adapter.getAllIds().map((id) => String(id))) : /* @__PURE__ */ new Set();
+  const beforeSnap = action.mode === "replace" ? await snapshotActivities(deps.adapter, existingActivityIds) : /* @__PURE__ */ new Map();
+  const beforeLinks = action.mode === "replace" ? snapshotAllLinks(deps) : /* @__PURE__ */ new Map();
+  const viewState = action.mode === "replace" ? captureDeletedViewState(deps.adapter, existingActivityIds) : [];
+  deps.scheduler.invalidateAllCaches();
+  const appliedLinks = [];
+  if (action.mode === "replace") {
+    for (const linkId of beforeLinks.keys()) {
+      const deleted = applyLinkOperation(
+        { kind: "delete", linkId },
+        { port: deps.adapter }
+      );
+      if (!deleted.applied) {
+        return {
+          ok: false,
+          reason: deleted.rejected ?? REJECTION_REASON.INVALID
+        };
+      }
+      appliedLinks.push({
+        op: { kind: "delete", linkId },
+        finalLinkId: linkId,
+        rejected: null
+      });
+    }
+    for (const activityId of existingActivityIds) {
+      const customId = deps.adapter.getActivity(activityId)?.customId;
+      if (typeof customId === "string" && customId.length > 0) {
+        deps.customIdTracker.releaseCustomId(customId);
+      }
+      deps.adapter.removeActivity(activityId);
+    }
+  }
+  const created = await createPlannedActivities(action, plan.plan.items, deps);
+  if (!created.ok) return created;
+  const correlativeShifts = isSimpleRootAppend(action) ? [] : recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(
+    plan.plan.items.map((item) => String(item.activityId))
+  );
+  const existingCorrelativeShifts = correlativeShifts.filter(
+    (shift) => !createdIdSet.has(shift.activityId)
+  );
+  const touchedIds = action.mode === "replace" ? new Set(existingActivityIds) : /* @__PURE__ */ new Set();
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnap,
+    touchedIds
+  );
+  for (const item of plan.plan.items) {
+    touchedIds.add(String(item.activityId));
+  }
+  const linkCreates = plan.plan.links.map((link) => ({
+    operation: {
+      kind: "create",
+      source: link.source,
+      target: link.target,
+      type: link.type,
+      lag: options.inputUnit === "hours" ? link.lag : lagDaysToHours(link.lag, deps.sector.hoursPerDay)
+    },
+    linkId: link.linkId
+  }));
+  const createdLinks = applyLinkCreates(linkCreates, {
+    port: deps.adapter,
+    preserved: beforeLinks
+  });
+  if (!createdLinks.applied) {
+    return {
+      ok: false,
+      reason: createdLinks.rejected ?? REJECTION_REASON.INVALID
+    };
+  }
+  for (const { operation, linkId } of linkCreates) {
+    appliedLinks.push({
+      op: operation,
+      finalLinkId: linkId,
+      rejected: null
+    });
+  }
+  const createdIds = plan.plan.items.map((item) => item.activityId);
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: action.items.length > 0 || action.links.length > 0 ? "roots" : null,
+      recomputeParentsFrom: createdIds,
+      now: deps.now,
+      options
+    }
+  );
+  const changes = await assembleChangeSet(deps.adapter, {
+    source: action,
+    beforeSnap,
+    touchedIds,
+    scheduledIds,
+    links: buildLinkChangesForBatch(appliedLinks, beforeLinks, deps.adapter),
+    hoursPerDay: deps.sector.hoursPerDay,
+    correlativeShifts: existingCorrelativeShifts,
+    ...action.mode === "replace" ? { sirDetection: "after-diff" } : {}
+  });
+  return {
+    ok: true,
+    changes: viewState.length > 0 ? { ...changes, viewState } : changes,
+    ...action.mode === "replace" ? {
+      __beforeSnap: beforeSnap,
+      __beforeLinks: stringKeyedLinks(beforeLinks)
+    } : {}
+  };
+}
+function validateBatch(action, deps) {
+  if (action.mode !== "append" && action.mode !== "replace") {
+    return REJECTION_REASON.INVALID;
+  }
+  const batchIds = /* @__PURE__ */ new Set();
+  const explicitActivityIds = /* @__PURE__ */ new Set();
+  for (const item of action.items) {
+    if (item.batchId.length === 0 || batchIds.has(item.batchId)) {
+      return REJECTION_REASON.INVALID;
+    }
+    batchIds.add(item.batchId);
+    if (item.index !== void 0 && (!Number.isInteger(item.index) || item.index < 0)) {
+      return REJECTION_REASON.INVALID;
+    }
+    if (item.activityId !== void 0) {
+      const activityId = String(item.activityId);
+      if (activityId.length === 0 || activityId === "0" || explicitActivityIds.has(activityId) || action.mode === "append" && deps.adapter.getActivity(activityId) !== null) {
+        return REJECTION_REASON.INVALID;
+      }
+      explicitActivityIds.add(activityId);
+    }
+  }
+  for (const item of action.items) {
+    if (!validReference(item.parent, true, action.mode, batchIds, deps)) {
+      return REJECTION_REASON.PARENT_NOT_FOUND;
+    }
+  }
+  if (hasParentCycle(action.items)) return REJECTION_REASON.INVALID;
+  const explicitLinkIds = /* @__PURE__ */ new Set();
+  for (const link of action.links) {
+    if (!Object.values(LINK_TYPE).includes(link.type) || !Number.isFinite(link.lag)) {
+      return !Number.isFinite(link.lag) ? REJECTION_REASON.INVALID_LINK_LAG : REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    if (!validReference(link.source, false, action.mode, batchIds, deps) || !validReference(link.target, false, action.mode, batchIds, deps)) {
+      return REJECTION_REASON.ACTIVITY_NOT_FOUND;
+    }
+    if (link.linkId !== void 0) {
+      const linkId = String(link.linkId);
+      if (linkId.length === 0 || explicitLinkIds.has(linkId) || action.mode === "append" && deps.adapter.getLink(linkId) !== null) {
+        return REJECTION_REASON.INVALID;
+      }
+      explicitLinkIds.add(linkId);
+    }
+  }
+  return null;
+}
+function validReference(reference, allowRoot, mode, batchIds, deps) {
+  if (typeof reference === "string") {
+    if (reference === "0") return allowRoot;
+    return mode === "append" && deps.adapter.getActivity(String(reference)) !== null;
+  }
+  return reference !== null && reference.batchId.length > 0 && batchIds.has(reference.batchId);
+}
+function hasParentCycle(items) {
+  const parentByBatchId = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (typeof item.parent !== "string") {
+      parentByBatchId.set(item.batchId, item.parent.batchId);
+    }
+  }
+  const verified = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const path = /* @__PURE__ */ new Set();
+    let current = item.batchId;
+    while (current !== void 0 && !verified.has(current)) {
+      if (path.has(current)) return true;
+      path.add(current);
+      current = parentByBatchId.get(current);
+    }
+    for (const batchId of path) verified.add(batchId);
+  }
+  return false;
+}
+function buildBatchPlan(action, deps) {
+  for (const item of action.items) {
+    if (item.activityId !== void 0) {
+      deps.activityIdGen.bump(item.activityId);
+    }
+  }
+  const activityIdsByBatchId = /* @__PURE__ */ new Map();
+  for (const item of action.items) {
+    activityIdsByBatchId.set(
+      item.batchId,
+      item.activityId ?? deps.activityIdGen.next()
+    );
+  }
+  for (const link of action.links) {
+    if (link.linkId !== void 0) deps.linkIdGen.bump(link.linkId);
+  }
+  const linkIds = action.links.map(
+    (link) => link.linkId ?? deps.linkIdGen.next()
+  );
+  const insertionCorrelativeIds = planInsertionCorrelatives(
+    action,
+    activityIdsByBatchId,
+    deps
+  );
+  const items = [];
+  for (const item of action.items) {
+    const activityId = activityIdsByBatchId.get(item.batchId);
+    const insertionCorrelativeId = insertionCorrelativeIds.get(item.batchId);
+    if (activityId === void 0 || insertionCorrelativeId === void 0) {
+      return { ok: false, reason: REJECTION_REASON.INVALID };
+    }
+    const parentBatchId = typeof item.parent === "string" ? null : item.parent.batchId;
+    const parentId = typeof item.parent === "string" ? item.parent : activityIdsByBatchId.get(item.parent.batchId);
+    if (parentId === void 0) {
+      return { ok: false, reason: REJECTION_REASON.PARENT_NOT_FOUND };
+    }
+    items.push({
+      input: item,
+      activityId,
+      parentId,
+      parentBatchId,
+      insertionCorrelativeId
+    });
+  }
+  const links = [];
+  for (const [index, link] of action.links.entries()) {
+    const source = resolveActivityReference(link.source, activityIdsByBatchId);
+    const target = resolveActivityReference(link.target, activityIdsByBatchId);
+    const linkId = linkIds[index];
+    if (source === null || target === null || linkId === void 0) {
+      return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+    }
+    links.push({
+      source,
+      target,
+      type: link.type,
+      lag: link.lag,
+      linkId
+    });
+  }
+  return { ok: true, plan: { items, links } };
+}
+function planInsertionCorrelatives(action, activityIdsByBatchId, deps) {
+  if (isSimpleRootAppend(action)) {
+    const firstCorrelativeId = deps.adapter.activityCount();
+    return new Map(
+      action.items.map((item, index) => [
+        item.batchId,
+        firstCorrelativeId + index
+      ])
+    );
+  }
+  const newIds = new Set(
+    Array.from(activityIdsByBatchId.values(), (id) => String(id))
+  );
+  const plansByParent = /* @__PURE__ */ new Map();
+  for (const item of action.items) {
+    const activityId = activityIdsByBatchId.get(item.batchId);
+    if (activityId === void 0) continue;
+    const parentId = typeof item.parent === "string" ? item.parent : activityIdsByBatchId.get(item.parent.batchId);
+    if (parentId === void 0) continue;
+    const parentKey = String(parentId);
+    let plan = plansByParent.get(parentKey);
+    if (!plan) {
+      const existing = action.mode === "replace" || typeof item.parent !== "string" && activityIdsByBatchId.has(item.parent.batchId) ? [] : collectSiblings(deps.adapter, parentKey).sort((left, right) => {
+        const diff = readCorrelativeId(left) - readCorrelativeId(right);
+        return diff || String(left.id).localeCompare(String(right.id));
+      }).map((activity) => String(activity.id));
+      plan = { existing, newIdsByTarget: /* @__PURE__ */ new Map() };
+      plansByParent.set(parentKey, plan);
+    }
+    const target = item.index === void 0 ? plan.existing.length : Math.min(item.index, plan.existing.length);
+    const idsAtTarget = plan.newIdsByTarget.get(target) ?? [];
+    idsAtTarget.push(String(activityId));
+    plan.newIdsByTarget.set(target, idsAtTarget);
+  }
+  const result = /* @__PURE__ */ new Map();
+  const batchIdByActivityId = new Map(
+    Array.from(activityIdsByBatchId, ([batchId, activityId]) => [
+      String(activityId),
+      batchId
+    ])
+  );
+  for (const plan of plansByParent.values()) {
+    const order = [];
+    for (let target = 0; target <= plan.existing.length; target += 1) {
+      for (const newId of plan.newIdsByTarget.get(target) ?? []) {
+        order.push(newId);
+      }
+      const existingId = plan.existing[target];
+      if (existingId !== void 0) order.push(existingId);
+    }
+    let index = 0;
+    while (index < order.length) {
+      if (!newIds.has(order[index])) {
+        index += 1;
+        continue;
+      }
+      const start = index;
+      while (index < order.length && newIds.has(order[index])) index += 1;
+      const count = index - start;
+      const left = start > 0 ? activityCorrelative(order[start - 1], deps) : null;
+      const right = index < order.length ? activityCorrelative(order[index], deps) : null;
+      for (let offset = 0; offset < count; offset += 1) {
+        const id = order[start + offset];
+        const batchId = batchIdByActivityId.get(id);
+        if (batchId === void 0) continue;
+        result.set(
+          batchId,
+          interpolateCorrelative(left, right, offset + 1, count)
+        );
+      }
+    }
+  }
+  return result;
+}
+function isSimpleRootAppend(action) {
+  return action.mode === "append" && action.items.every(
+    (item) => item.parent === "0" && item.index === void 0
+  );
+}
+function activityCorrelative(activityId, deps) {
+  const activity = deps.adapter.getActivity(activityId);
+  return activity ? readCorrelativeId(activity) : 0;
+}
+function interpolateCorrelative(left, right, position, count) {
+  if (left !== null && right !== null && right > left) {
+    return left + (right - left) * position / (count + 1);
+  }
+  if (left !== null) return left + position;
+  if (right !== null) return right - (count - position + 1);
+  return position - 1;
+}
+async function createPlannedActivities(action, plannedItems, deps) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const ready = [];
+  for (const item of plannedItems) {
+    if (item.parentBatchId === null) {
+      ready.push(item);
+      continue;
+    }
+    const children = childrenByParent.get(item.parentBatchId) ?? [];
+    children.push(item);
+    childrenByParent.set(item.parentBatchId, children);
+  }
+  for (let index = 0; index < ready.length; index += 1) {
+    const item = ready[index];
+    const core = await createActivityCore(
+      {
+        parentId: item.parentId,
+        activityId: item.activityId,
+        ...item.input.overrides === void 0 ? {} : { overrides: item.input.overrides },
+        ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+      },
+      deps,
+      {
+        skipCorrelativeRecompute: true,
+        skipBeforeSnap: true,
+        skipCacheInvalidation: true,
+        skipRollupCascades: true,
+        insertionCorrelativeId: item.insertionCorrelativeId
+      }
+    );
+    if (!core.ok) return core;
+    for (const child of childrenByParent.get(item.input.batchId) ?? []) {
+      ready.push(child);
+    }
+  }
+  if (ready.length !== plannedItems.length) {
+    return { ok: false, reason: REJECTION_REASON.INVALID };
+  }
+  const recomputedParents = /* @__PURE__ */ new Set();
+  for (let index = ready.length - 1; index >= 0; index -= 1) {
+    const parentId = ready[index].parentId;
+    if (parentId === "0" || recomputedParents.has(String(parentId))) continue;
+    recomputedParents.add(String(parentId));
+    recomputeRollupCascadesForParent(parentId, deps.adapter);
+  }
+  return { ok: true };
+}
+function resolveActivityReference(reference, activityIdsByBatchId) {
+  if (typeof reference === "string") return reference;
+  return activityIdsByBatchId.get(reference.batchId) ?? null;
+}
+function snapshotAllLinks(deps) {
+  return new Map(
+    deps.adapter.getAllLinks().map((link) => [String(link.id), { ...link }])
+  );
+}
+function stringKeyedLinks(links) {
+  return new Map(Array.from(links, ([linkId, link]) => [String(linkId), link]));
+}
+
+// src/dispatch/handlers/activity-paste.ts
+function resolvePasteRootDestination(destination, adapter) {
+  if ("afterSiblingId" in destination) {
+    const sibling = adapter.getActivity(destination.afterSiblingId);
+    if (!sibling) {
+      return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
+    }
+    const parentId2 = sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId);
+    return { ok: true, parentId: parentId2, firstAfter: destination.afterSiblingId };
+  }
+  const parentId = destination.parentId;
+  const siblings = collectSiblings(adapter, parentId).sort(
+    (a, b) => readCorrelativeId(a) - readCorrelativeId(b)
+  );
+  const before = siblings[destination.index]?.id;
+  return { ok: true, parentId, firstBefore: before };
+}
+function applyPasteDomainSemantics(overrides) {
+  const { customId: _customId, ...content } = overrides;
+  return {
+    ...content,
+    progress: 0,
+    ponderator: 0,
+    usedCost: 0,
+    workHours: 0,
+    isLookahead: false
+  };
+}
+async function dispatchActivityPaste(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  const rootDest = resolvePasteRootDestination(action.destination, adapter);
+  if (!rootDest.ok) return rootDest;
+  const beforeSnap = await snapshotActivities(adapter, /* @__PURE__ */ new Set());
+  const touched = /* @__PURE__ */ new Set();
+  const originalToNew = /* @__PURE__ */ new Map();
+  const createdIds = [];
+  let prevRootId;
+  for (const input of action.activities) {
+    const mappedParent = originalToNew.get(input.originalParentId);
+    let parentId;
+    let afterSiblingId;
+    let beforeSiblingId;
+    if (mappedParent !== void 0) {
+      parentId = mappedParent;
+    } else {
+      parentId = rootDest.parentId;
+      if (prevRootId === void 0) {
+        afterSiblingId = rootDest.firstAfter;
+        beforeSiblingId = rootDest.firstBefore;
+      } else {
+        afterSiblingId = prevRootId;
+      }
+    }
+    const core = await createActivityCore(
+      {
+        parentId,
+        afterSiblingId,
+        beforeSiblingId,
+        ...input.activityId ? { activityId: input.activityId } : {},
+        overrides: applyPasteDomainSemantics(input.overrides),
+        eventSource: action.eventSource
+      },
+      deps,
+      {
+        skipCorrelativeRecompute: true,
+        skipBeforeSnap: true,
+        customIdReferenceId: action.referenceActivityId
+      }
+    );
+    if (!core.ok) return core;
+    if (input.baselineSnapshot !== void 0) {
+      const snapshot = input.baselineSnapshot;
+      adapter.setActivityField(
+        core.newId,
+        "baselineSnapshot",
+        snapshot ? {
+          ...snapshot,
+          startDate: snapshot.startDate ? new Date(snapshot.startDate) : null,
+          endDate: snapshot.endDate ? new Date(snapshot.endDate) : null
+        } : null
+      );
+    }
+    originalToNew.set(input.originalId, core.newId);
+    createdIds.push(core.newId);
+    if (mappedParent === void 0) prevRootId = core.newId;
+  }
+  const correlativeShifts = recomputeCorrelativeIds(adapter);
+  const createdIdSet = new Set(createdIds.map(String));
+  foldCorrelativeShifts(
+    adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnap,
+    touched
+  );
+  for (const createdId of createdIds) touched.add(String(createdId));
+  const appliedLinks = [];
+  for (const link of action.links) {
+    const newSource = originalToNew.get(link.source);
+    const newTarget = originalToNew.get(link.target);
+    if (newSource === void 0 || newTarget === void 0) continue;
+    const op = {
+      kind: "create",
+      source: newSource,
+      target: newTarget,
+      type: link.type,
+      lag: lagDaysToHours(link.lag, sector.hoursPerDay)
+    };
+    const res = applyLinkOperation(op, {
+      port: adapter,
+      newLinkId: link.linkId ? () => link.linkId : deps.linkIdGen.next
+    });
+    appliedLinks.push({
+      op,
+      finalLinkId: res.applied ? res.linkId : null,
+      rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
+    });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: createdIds[0] ?? null,
+      recomputeParentsFrom: createdIds,
+      now: deps.now,
+      options
+    }
+  );
+  const linkChanges = buildLinkChangesForBatch(
+    appliedLinks,
+    /* @__PURE__ */ new Map(),
+    adapter
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: touched,
+      scheduledIds,
+      links: linkChanges,
+      hoursPerDay: sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/sir-sync.ts
+function dispatchSirSync(action, deps) {
+  const { adapter } = deps;
+  const id = action.activityId;
+  const snapshot = adapter.getActivity(id);
+  if (!snapshot) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  const before = snapshot.pendingRequestIds ?? [];
+  const after = action.pendingRequests.map((r) => r.id);
+  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
+  const change = {
+    id,
+    kind: "updated",
+    fields: { pendingRequestIds: { before, after } },
+    after: { id, pendingRequestIds: after }
+  };
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: [change],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
+  };
+}
+
+// src/dispatch/handlers/activity-lookahead-sync.ts
+function dispatchActivityLookaheadSync(action, deps) {
+  const ids = [...new Set(action.activityIds.map(String))];
+  const snapshots = ids.map((id) => deps.adapter.getActivity(id));
+  if (snapshots.some((snapshot) => !snapshot)) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  const activities = [];
+  for (const [index, id] of ids.entries()) {
+    const snapshot = snapshots[index];
+    if (!snapshot) continue;
+    const fields = {};
+    if (snapshot.isLookahead !== action.isLookahead) {
+      fields.isLookahead = {
+        before: snapshot.isLookahead,
+        after: action.isLookahead
+      };
+      deps.adapter.setActivityField(id, "isLookahead", action.isLookahead);
+    }
+    if (snapshot.hasLookaheadTasks !== action.hasLookaheadTasks) {
+      fields.hasLookaheadTasks = {
+        before: snapshot.hasLookaheadTasks,
+        after: action.hasLookaheadTasks
+      };
+      deps.adapter.setActivityField(
+        id,
+        "hasLookaheadTasks",
+        action.hasLookaheadTasks
+      );
+    }
+    if (Object.keys(fields).length === 0) continue;
+    activities.push({
+      id,
+      kind: "updated",
+      fields,
+      after: {
+        ...snapshot,
+        isLookahead: action.isLookahead,
+        hasLookaheadTasks: action.hasLookaheadTasks
+      }
+    });
+  }
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities,
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
+  };
 }
 
 // src/internal/hierarchy/invalid-links.ts
@@ -12790,7 +13492,10 @@ async function dispatchStatusCriteriaSet(action, deps) {
 }
 
 // src/dispatch/dispatch.ts
-async function dispatch(action, options, deps) {
+async function performDispatch(action, options, deps) {
+  if (action.kind === "activity-batch") {
+    return dispatchActivityBatch(action, options, deps);
+  }
   if (action.kind === "persistence-acknowledge") {
     return dispatchPersistenceAcknowledge(action, deps);
   }
@@ -16024,6 +16729,7 @@ var ScheduleState = class {
   };
   _writeCapture = new WriteCapture();
   _viewState = new ViewStateStore();
+  _filterProjection = null;
   _viewStateBefore = null;
   _lastStartDateBefore = null;
   _promotionSnapshotBefore = null;
@@ -16138,6 +16844,13 @@ var ScheduleState = class {
   setActiveFilter(nextFilter) {
     this._captureViewStateOnce();
     this._viewState.setActiveFilter(nextFilter);
+    this._filterProjection = null;
+  }
+  getFilterProjection() {
+    return this._filterProjection;
+  }
+  setFilterProjection(projection) {
+    this._filterProjection = projection;
   }
   getActiveOrder() {
     return this._viewState.getActiveOrder();
@@ -16179,6 +16892,7 @@ var ScheduleState = class {
   }
   hydrateViewState(seed2) {
     this._viewState.hydrate(seed2);
+    this._filterProjection = null;
     this.invalidateDerivedOrder();
   }
   _captureViewStateOnce() {
@@ -16379,6 +17093,7 @@ var ScheduleState = class {
     this._restoreActivityFields(before);
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
+      this._filterProjection = null;
       this.invalidateDerivedOrder();
     }
     if (this._promotionSnapshotBefore !== null) {
@@ -16588,8 +17303,10 @@ function buildHistoryChangeSet(changes) {
     ...entry,
     after: null
   }));
+  const source = changes.source.kind === "activity-batch" ? { ...changes.source, items: [], links: [] } : changes.source;
   return cloneDomainValue({
     ...changes,
+    source,
     activities: activitiesWithoutAfter,
     links: linksWithoutAfter
   });
@@ -16606,7 +17323,7 @@ function captureCreatedSnapshots(state, changeSet) {
     if (live) afterSnap.set(String(ch.id), structuredCloneActivity(live));
   }
   for (const ch of changeSet.links) {
-    if (ch.kind !== "created") continue;
+    if (ch.kind === "deleted") continue;
     const live = state.getLink(String(ch.id));
     if (live) afterLinks.set(String(ch.id), { ...live });
   }
@@ -16829,6 +17546,17 @@ function applyChangeSetSide(state, entry, side) {
   for (const ch of cs.links) {
     if (ch.kind === "updated") {
       if (!ch.fields) continue;
+      if (Object.hasOwn(ch.fields, "source") || Object.hasOwn(ch.fields, "target")) {
+        const snapshot = side === "before" ? entry.beforeLinks?.get(String(ch.id)) : entry.afterLinks?.get(String(ch.id));
+        if (!snapshot) {
+          throw new Error(
+            `${side === "before" ? "undo" : "redo"}: missing link snapshot for ${ch.id}`
+          );
+        }
+        state.removeLink(String(ch.id));
+        state.addLink({ ...snapshot });
+        continue;
+      }
       for (const [field, fv] of Object.entries(ch.fields)) {
         setLinkFieldDynamic(
           state,
@@ -17099,9 +17827,26 @@ function idArrayEquals(current, saved) {
   return currentIds.every((value, index) => value === savedIds[index]);
 }
 
+// src/boundary/save/link-changes.ts
+function linkChangedSince(baseline, current) {
+  return baseline.source !== current.source || baseline.target !== current.target || baseline.lag !== current.lag || baseline.type !== current.type;
+}
+function checkNoUpdatedLinks(baseline, current) {
+  const baselineById = new Map(
+    baseline.map((link) => [String(link.id), link])
+  );
+  return current.filter((link) => {
+    const base = baselineById.get(String(link.id));
+    if (!base) return false;
+    return linkChangedSince(base, link);
+  });
+}
+
 // src/boundary/save/save-tracker.ts
 var SaveTracker = class {
   initialized = false;
+  dirtyActivityIds = /* @__PURE__ */ new Set();
+  dirtyLinkIds = /* @__PURE__ */ new Set();
   linksAtLastSave = /* @__PURE__ */ new Map();
   activitiesAtLastSave = /* @__PURE__ */ new Map();
   init(activities, links) {
@@ -17111,10 +17856,16 @@ var SaveTracker = class {
   }
   snapshotActivities(activities) {
     this.activitiesAtLastSave.clear();
+    this.dirtyActivityIds.clear();
     for (const activity of activities) {
-      if (activity.proplannerId == null) continue;
+      const activityId = String(activity.id);
+      if (activity.proplannerId == null) {
+        this.dirtyActivityIds.add(activityId);
+        continue;
+      }
+      const persistable = projectPersistableActivity(activity);
       this.activitiesAtLastSave.set(String(activity.id), {
-        persistable: projectPersistableActivity(activity),
+        persistable,
         deletedSnapshot: {
           id: activity.id,
           proplannerId: activity.proplannerId,
@@ -17122,12 +17873,20 @@ var SaveTracker = class {
           hadBaseline: activity.baselineSnapshot !== null || activity.baselinePoints.length > 0
         }
       });
+      if (activityChangedSince(activity, persistable)) {
+        this.dirtyActivityIds.add(activityId);
+      }
     }
   }
   snapshotLinks(links) {
     this.linksAtLastSave.clear();
+    this.dirtyLinkIds.clear();
     for (const link of links) {
-      if (link.proplannerId == null) continue;
+      const linkId = String(link.id);
+      if (link.proplannerId == null) {
+        this.dirtyLinkIds.add(linkId);
+        continue;
+      }
       this.linksAtLastSave.set(String(link.id), {
         id: link.id,
         proplannerId: link.proplannerId,
@@ -17138,21 +17897,52 @@ var SaveTracker = class {
       });
     }
   }
-  hasUnsavedChanges(activities, links) {
-    if (!this.initialized) return false;
-    if (this.deletedActivities(activities).length > 0) return true;
-    if (this.deletedLinks(links).length > 0) return true;
-    const activityChanged = activities.some((activity) => {
-      if (activity.proplannerId == null) return true;
-      const saved = this.activitiesAtLastSave.get(String(activity.id));
-      return !saved || activityChangedSince(activity, saved.persistable);
-    });
-    if (activityChanged) return true;
-    return links.some((link) => {
-      if (link.proplannerId == null) return true;
-      const saved = this.linksAtLastSave.get(String(link.id));
-      return !saved || link.lag !== saved.lag || link.type !== saved.type;
-    });
+  recordChanges(activities, links, getActivity, getLink) {
+    if (!this.initialized) return;
+    for (const change of activities) {
+      const activityId = String(change.id);
+      const current = getActivity(activityId);
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (current === null ? saved !== void 0 : current.proplannerId == null || saved === void 0 || activityChangedSince(current, saved.persistable)) {
+        this.dirtyActivityIds.add(activityId);
+      } else {
+        this.dirtyActivityIds.delete(activityId);
+      }
+    }
+    for (const change of links) {
+      const linkId = String(change.id);
+      const current = getLink(linkId);
+      const saved = this.linksAtLastSave.get(linkId);
+      if (current === null ? saved !== void 0 : current.proplannerId == null || saved === void 0 || linkChangedSince(saved, current)) {
+        this.dirtyLinkIds.add(linkId);
+      } else {
+        this.dirtyLinkIds.delete(linkId);
+      }
+    }
+  }
+  acknowledgePersistedLookahead(activityIds, getActivity) {
+    if (!this.initialized) return;
+    for (const activityId of activityIds) {
+      const current = getActivity(activityId);
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (current === null || saved === void 0) continue;
+      const persistable = {
+        ...saved.persistable,
+        isLookahead: current.isLookahead
+      };
+      this.activitiesAtLastSave.set(activityId, {
+        ...saved,
+        persistable
+      });
+      if (current.proplannerId == null || activityChangedSince(current, persistable)) {
+        this.dirtyActivityIds.add(activityId);
+      } else {
+        this.dirtyActivityIds.delete(activityId);
+      }
+    }
+  }
+  hasUnsavedChanges() {
+    return this.initialized && (this.dirtyActivityIds.size > 0 || this.dirtyLinkIds.size > 0);
   }
   deletedActivities(activities) {
     if (!this.initialized) return [];
@@ -17190,10 +17980,13 @@ var SaveTracker = class {
       if (link.proplannerId == null) return false;
       const saved = this.linksAtLastSave.get(String(link.id));
       if (!saved) return true;
-      return link.lag !== saved.lag || link.type !== saved.type;
+      return linkChangedSince(saved, link);
     });
   }
   clear() {
+    this.initialized = false;
+    this.dirtyActivityIds.clear();
+    this.dirtyLinkIds.clear();
     this.linksAtLastSave.clear();
     this.activitiesAtLastSave.clear();
   }
@@ -17795,6 +18588,12 @@ function createActivityIdGenerator(options = {}) {
       const n = typeof id === "number" ? id : Number(id);
       if (!Number.isFinite(n)) return;
       raise(n);
+    },
+    snapshot() {
+      return counter;
+    },
+    restore(snapshot) {
+      counter = snapshot;
     }
   };
 }
@@ -17820,6 +18619,12 @@ function createLinkIdGenerator(options = {}) {
       const n = typeof id === "number" ? id : Number(id);
       if (!Number.isFinite(n)) return;
       raise(n);
+    },
+    snapshot() {
+      return counter;
+    },
+    restore(snapshot) {
+      counter = snapshot;
     }
   };
 }
@@ -17849,6 +18654,12 @@ function createUniqueCorrelativeIdGenerator(options = {}) {
       if (uid2 == null) return;
       const n = typeof uid2 === "number" ? uid2 : Number(uid2);
       raise(n);
+    },
+    snapshot() {
+      return counter;
+    },
+    restore(snapshot) {
+      counter = snapshot;
     }
   };
 }
@@ -17925,13 +18736,13 @@ function minSuffixFromArray(suffixes) {
   if (!suffixes || suffixes.length === 0) {
     throw new Error("minSuffixFromArray requires non-empty array");
   }
-  return suffixes.reduce((min, current) => minSuffix(min, current));
+  return suffixes.reduce((min2, current) => minSuffix(min2, current));
 }
 function maxSuffixFromArray(suffixes) {
   if (!suffixes || suffixes.length === 0) {
     throw new Error("maxSuffixFromArray requires non-empty array");
   }
-  return suffixes.reduce((max, current) => maxSuffix(max, current));
+  return suffixes.reduce((max2, current) => maxSuffix(max2, current));
 }
 
 // src/generators/custom-id/generation-strategies.ts
@@ -18625,13 +19436,204 @@ function initializeCore(input) {
   };
 }
 
+// src/propagations/upward/date-gesture-preview.ts
+var emptyFormula = () => ({
+  constantStart: null,
+  variableStartOffset: null,
+  constantEnd: null,
+  variableEndOffset: null
+});
+var min = (left, right) => left === null ? right : Math.min(left, right);
+var max = (left, right) => left === null ? right : Math.max(left, right);
+function createDateGesturePreview(adapter, gesture, assertCurrent) {
+  const participantIds = [
+    ...new Set(
+      gesture.kind === "move" ? gesture.activityIds.map(String) : [String(gesture.activityId)]
+    )
+  ];
+  if (participantIds.length === 0) {
+    throw new Error("[ScheduleCore] date gesture has no participants");
+  }
+  const formulas = buildParticipantFormulas(adapter, gesture, participantIds);
+  addAncestorFormulas(adapter, participantIds, formulas);
+  return {
+    getDates(activityId, proposedEdgeTimeMs) {
+      assertCurrent();
+      if (!Number.isFinite(proposedEdgeTimeMs)) {
+        throw new Error("[ScheduleCore] invalid date gesture edge");
+      }
+      const formula = formulas.get(String(activityId));
+      if (!formula) return null;
+      const startTimeMs = evaluateStart(formula, proposedEdgeTimeMs);
+      const endTimeMs = evaluateEnd(formula, proposedEdgeTimeMs);
+      if (startTimeMs === null || endTimeMs === null) {
+        throw new Error(
+          `[ScheduleCore] incomplete date gesture bounds for ${String(activityId)}`
+        );
+      }
+      return { startTimeMs, endTimeMs };
+    }
+  };
+}
+function buildParticipantFormulas(adapter, gesture, participantIds) {
+  const formulas = /* @__PURE__ */ new Map();
+  const anchorId = gesture.kind === "move" ? String(gesture.anchorActivityId) : null;
+  const anchor = anchorId === null ? null : requireLeafActivity(adapter, anchorId);
+  if (anchorId !== null && !participantIds.includes(anchorId)) {
+    throw new Error("[ScheduleCore] move anchor is not a participant");
+  }
+  for (const activityId of participantIds) {
+    const activity = requireLeafActivity(adapter, activityId);
+    if (gesture.kind === "move") {
+      const anchorStart = anchor.startDate.getTime();
+      formulas.set(activityId, {
+        constantStart: null,
+        variableStartOffset: activity.startDate.getTime() - anchorStart,
+        constantEnd: null,
+        variableEndOffset: activity.endDate.getTime() - anchorStart
+      });
+    } else if (gesture.kind === "resize-start") {
+      formulas.set(activityId, {
+        constantStart: null,
+        variableStartOffset: 0,
+        constantEnd: activity.endDate.getTime(),
+        variableEndOffset: null
+      });
+    } else {
+      formulas.set(activityId, {
+        constantStart: activity.startDate.getTime(),
+        variableStartOffset: null,
+        constantEnd: null,
+        variableEndOffset: 0
+      });
+    }
+  }
+  return formulas;
+}
+function addAncestorFormulas(adapter, participantIds, formulas) {
+  const ancestors = findAncestorsOfDirty(adapter, new Set(participantIds));
+  for (const parentId of ancestors) {
+    const formula = emptyFormula();
+    for (const childId of adapter.getChildren(parentId)) {
+      const childFormula = formulas.get(childId);
+      if (childFormula) {
+        mergeFormula(formula, childFormula);
+        continue;
+      }
+      const child = adapter.getActivity(childId);
+      if (!child) {
+        throw new Error(
+          `[ScheduleCore] missing child ${childId} while previewing parent ${parentId}`
+        );
+      }
+      formula.constantStart = min(
+        formula.constantStart,
+        child.startDate.getTime()
+      );
+      formula.constantEnd = max(formula.constantEnd, child.endDate.getTime());
+    }
+    formulas.set(parentId, formula);
+  }
+}
+function requireLeafActivity(adapter, activityId) {
+  const activity = adapter.getActivity(activityId);
+  if (!activity) {
+    throw new Error(
+      `[ScheduleCore] missing date gesture activity ${activityId}`
+    );
+  }
+  if (adapter.hasChildren(activityId)) {
+    throw new Error(
+      `[ScheduleCore] summary activity ${activityId} cannot be dragged directly`
+    );
+  }
+  return activity;
+}
+function mergeFormula(target, source) {
+  if (source.constantStart !== null) {
+    target.constantStart = min(target.constantStart, source.constantStart);
+  }
+  if (source.variableStartOffset !== null) {
+    target.variableStartOffset = min(
+      target.variableStartOffset,
+      source.variableStartOffset
+    );
+  }
+  if (source.constantEnd !== null) {
+    target.constantEnd = max(target.constantEnd, source.constantEnd);
+  }
+  if (source.variableEndOffset !== null) {
+    target.variableEndOffset = max(
+      target.variableEndOffset,
+      source.variableEndOffset
+    );
+  }
+}
+function evaluateStart(formula, proposedEdgeTimeMs) {
+  if (formula.variableStartOffset === null) return formula.constantStart;
+  const variable = proposedEdgeTimeMs + formula.variableStartOffset;
+  return formula.constantStart === null ? variable : Math.min(formula.constantStart, variable);
+}
+function evaluateEnd(formula, proposedEdgeTimeMs) {
+  if (formula.variableEndOffset === null) return formula.constantEnd;
+  const variable = proposedEdgeTimeMs + formula.variableEndOffset;
+  return formula.constantEnd === null ? variable : Math.max(formula.constantEnd, variable);
+}
+
 // src/init/schedule-core.ts
+function changesRequireFilterProjectionRebuild(changes) {
+  for (const change of changes.activities) {
+    if (change.kind === "deleted") return true;
+    const hasMovedParent = change.kind === "updated" && change.fields !== void 0 && "parentId" in change.fields;
+    if (hasMovedParent) return true;
+  }
+  return false;
+}
+function collectChangedActivities(changes, adapter) {
+  const activities = [];
+  for (const change of changes.activities) {
+    const activity = adapter.getActivity(change.id);
+    if (activity === null) return null;
+    activities.push(activity);
+  }
+  return activities;
+}
+function isCurrentFilterProjection(projection, filter, context) {
+  if (projection === null || projection.filter !== filter) return false;
+  const hasCurrentHours = projection.context.hoursPerDay === context.hoursPerDay;
+  const hasCurrentLocale = projection.context.locale === context.locale;
+  return hasCurrentHours && hasCurrentLocale;
+}
 var ScheduleCore = class {
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
   _undo = new UndoRecorder();
   _opQueue = Promise.resolve();
   _scheduleRevision = 0;
+  /**
+   * Revision counting mutations that have been ADMITTED, whether or not they
+   * have changed anything yet. `_scheduleRevision` counts the ones that
+   * actually did.
+   *
+   * INVARIANT: `_pendingScheduleRevision >= _scheduleRevision`, and equality
+   * means no mutation is in flight.
+   *
+   * The two exist separately because the useful instant and the knowable
+   * instant are not the same one. A critical-path calculation becomes garbage
+   * the moment the next mutation is admitted, but whether that mutation is
+   * substantive is only knowable once its ChangeSet exists, which is hundreds
+   * of milliseconds later at project scale. Measured live on a 12268-activity
+   * project: the cancellation flag flipped 929 ms into a 930 ms calculation,
+   * 812 into 812 and 785 into 785, because the job's apply block queues behind
+   * the very dispatch whose completion cancels it. Cancellation and job end
+   * were the same event, so every discarded job ran the whole calculation.
+   *
+   * Splitting the counter buys the early signal without moving the meaning of
+   * `_scheduleRevision`, whose three readers (`isCriticalPathSettled`,
+   * `createDateGesturePreview` and the job's own `isCurrent`) are all written
+   * against "the state actually changed".
+   */
+  _pendingScheduleRevision = 0;
   _criticalPathRevision = -1;
   _activeCriticalPath = null;
   constructor(input) {
@@ -18684,6 +19686,16 @@ var ScheduleCore = class {
     this.assertReady();
     return readActivity(this.coreRuntime.state, id);
   }
+  createDateGesturePreview(gesture) {
+    this.assertReady();
+    const revision = this._scheduleRevision;
+    return createDateGesturePreview(this.coreRuntime.state, gesture, () => {
+      this.assertReady();
+      if (this._scheduleRevision !== revision) {
+        throw new Error("[ScheduleCore] date gesture preview is stale");
+      }
+    });
+  }
   getAllActivitiesView() {
     this.assertReady();
     return readAllActivities(this.coreRuntime.state);
@@ -18781,10 +19793,7 @@ var ScheduleCore = class {
   }
   hasUnsavedChanges() {
     this.assertReady();
-    return this._saveTracker.hasUnsavedChanges(
-      this.coreRuntime.state.getAllActivities(),
-      this.getAllLinksView()
-    );
+    return this._saveTracker.hasUnsavedChanges();
   }
   getDeletedActivitiesSinceLastSave() {
     this.assertReady();
@@ -18802,10 +19811,90 @@ var ScheduleCore = class {
     );
     return workPromise;
   }
+  /**
+   * Marks a mutation as admitted and invalidates the calculation in flight.
+   *
+   * Called BEFORE `_enqueue`, which is the point of the whole thing: the wait
+   * in the operation queue is part of the window a running calculation wastes,
+   * and it is the longest part of it when several mutations are already
+   * queued.
+   *
+   * `dispatchChangesSchedulingState` is a pure function of the action, so this
+   * decision needs no state and cannot be wrong about the action's nature. What
+   * it cannot know yet is whether the mutation will produce anything, which is
+   * what `_settleScheduleMutation` reconciles afterwards.
+   */
+  _beginScheduleMutation(action) {
+    if (!dispatchChangesSchedulingState(action)) return false;
+    return this._admitScheduleMutation();
+  }
+  /** Undo and redo have no action to classify: reaching them IS the mutation. */
+  _admitScheduleMutation() {
+    this._pendingScheduleRevision++;
+    if (this._activeCriticalPath) {
+      this._activeCriticalPath.cancellation.cancelled = true;
+    }
+    return true;
+  }
+  /**
+   * Closes a mutation admitted by `_beginScheduleMutation`, on EVERY exit path.
+   *
+   * `changedState` false means the mutation was admitted and produced nothing
+   * (rejected, non-substantive, or rolled back). The pending revision walks
+   * back so the invariant holds and `isCriticalPathSettled` keeps telling the
+   * truth, and the calculation this mutation killed for nothing is re-armed.
+   *
+   * The re-arm goes through the queue and that is not incidental. Started
+   * outside it, the calculation would run immediately while the next queued
+   * mutation is still waiting, and that mutation would kill it again on
+   * admission: a cancel-and-restart treadmill burning a fresh project-wide deep
+   * copy per lap. Inside the queue the restart cannot happen until the queue
+   * drains, so at most one calculation is armed per settled mutation. The burst
+   * scenario will NOT catch a regression here, because there every dispatch
+   * succeeds and this path is never taken.
+   *
+   * It re-arms through `recomputeCriticalPath` rather than enqueueing the job
+   * directly, because the queue slot must NOT await the job: the job's own
+   * apply block needs a later slot on this same queue, so awaiting it from
+   * inside a slot deadlocks the core. `recomputeCriticalPath` already has the
+   * shape that returns the job's promise out of the slot instead of awaiting
+   * it, and it keeps `_criticalPathReady` pointing at the live calculation.
+   */
+  _settleScheduleMutation(admitted, changedState) {
+    if (!admitted) return;
+    if (changedState) return;
+    this._pendingScheduleRevision = Math.max(
+      this._pendingScheduleRevision - 1,
+      this._scheduleRevision
+    );
+    if (this._pendingScheduleRevision !== this._scheduleRevision) return;
+    if (this._criticalPathRevision === this._scheduleRevision) return;
+    void this.recomputeCriticalPath().catch((error) => {
+      this.coreRuntime.reporter.error(
+        "[ScheduleCore] Critical Path re-arm after a barren mutation failed",
+        error
+      );
+    });
+  }
   async dispatch(action, options = {}) {
-    return this._enqueue(() => this._dispatchInner(action, options));
+    const admitted = this._beginScheduleMutation(action);
+    return this._enqueue(() => this._dispatchInner(action, options, admitted));
+  }
+  async applyActivityBatch(action, options = {}) {
+    const admitted = this._beginScheduleMutation(action);
+    return this._enqueue(() => this._dispatchInner(action, options, admitted));
+  }
+  async _dispatchInner(action, options = {}, admitted = false) {
+    let changedState = false;
+    try {
+      const dispatched = await this._runDispatch(action, options);
+      changedState = dispatched.changedState;
+      return dispatched.result;
+    } finally {
+      this._settleScheduleMutation(admitted, changedState);
+    }
   }
-  async _dispatchInner(action, options = {}) {
+  async _runDispatch(action, options) {
     this.assertReady();
     const pipelineContext = buildPipelineContext(this.coreRuntime.state, {
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
@@ -18813,11 +19902,16 @@ var ScheduleCore = class {
       inputUnit: options.inputUnit ?? "days"
     });
     const historyPolicy = getDispatchHistoryPolicy(action);
+    const generatorSnapshot = [
+      this.coreRuntime.activityIdGenerator.snapshot(),
+      this.coreRuntime.linkIdGenerator.snapshot(),
+      this.coreRuntime.uniqueCorrelativeIdGenerator.snapshot()
+    ];
     this.coreRuntime.state.beginWriteCapture();
     this.coreRuntime.customIdTracker.beginCustomIdTransaction();
     let result;
     try {
-      result = await dispatch(action, options, {
+      result = await performDispatch(action, options, {
         adapter: this.coreRuntime.state,
         ctx: pipelineContext,
         scheduler: this.coreRuntime.scheduler,
@@ -18833,9 +19927,9 @@ var ScheduleCore = class {
         )?.id ?? null,
         now: this.coreRuntime.clock ? endOfLocalDay(this.coreRuntime.clock()) : null
       });
-      if (!result.ok) this._rollback();
+      if (!result.ok) this._rollback(generatorSnapshot);
     } catch (error) {
-      this._rollback();
+      this._rollback(generatorSnapshot);
       throw error;
     } finally {
       this.coreRuntime.state.endWriteCapture();
@@ -18858,19 +19952,36 @@ 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) {
+      if (historyPolicy === "clear-on-success") {
+        this._saveTracker.snapshotActivities(
+          this.coreRuntime.state.getAllActivities()
+        );
+        this._saveTracker.snapshotLinks(this.getAllLinksView());
+        this._undo.clear();
+      } else if (action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true) {
+        this._saveTracker.acknowledgePersistedLookahead(
+          action.activityIds,
+          (activityId) => this.coreRuntime.state.getActivity(activityId)
+        );
+      } else {
+        this._saveTracker.recordChanges(
+          result.changes.activities,
+          result.changes.links,
+          (activityId) => this.coreRuntime.state.getActivity(activityId),
+          (linkId) => this.coreRuntime.state.getLink(linkId)
+        );
+      }
     }
     result = this._withReappliedViewState(action, result);
-    if (!result.ok) return result;
+    if (!result.ok) return { result, changedState: false };
     if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
-      this._recordScheduleMutation(options.skipCriticalPath !== true);
+      this._recordScheduleMutation(
+        options.skipAutoSchedule !== true && options.skipCriticalPath !== true && resolveRunCriticalPath(action)
+      );
+      return { result: toPublicDispatchResult(result), changedState: true };
     }
-    return toPublicDispatchResult(result);
+    return { result: toPublicDispatchResult(result), changedState: false };
   }
   recomputeCriticalPath() {
     const operation = this._enqueue(async () => ({
@@ -18880,7 +19991,11 @@ var ScheduleCore = class {
     return operation;
   }
   isCriticalPathSettled() {
-    return this._criticalPathRevision === this._scheduleRevision && this._activeCriticalPath === null;
+    return this._criticalPathRevision === this._scheduleRevision && // An admitted mutation has not landed yet, so whatever is applied now is
+    // about to be stale. Without this term `whenCriticalPathSettled` would
+    // spin: it would keep arming calculations that `isCurrent` kills on their
+    // first check, each one paying the project-wide deep copy first.
+    this._pendingScheduleRevision === this._scheduleRevision && this._activeCriticalPath === null;
   }
   async whenCriticalPathSettled() {
     while (!this.isCriticalPathSettled()) {
@@ -18888,7 +20003,11 @@ var ScheduleCore = class {
     }
   }
   _withReappliedViewState(action, result) {
-    if (!result.ok || !reappliesViewState(action)) return result;
+    if (!result.ok) return result;
+    if (action.kind === "visibility-set") {
+      this.coreRuntime.state.setFilterProjection(null);
+    }
+    if (!reappliesViewState(action)) return result;
     const merged = this._reapplyViewState(result.changes);
     return merged === null ? result : { ...result, changes: merged };
   }
@@ -18909,11 +20028,44 @@ var ScheduleCore = class {
    */
   _reapplyViewState(changes) {
     const withFilter = this._reapplyActiveFilter(changes);
-    const withOrder = this._reapplyActiveOrder(withFilter ?? changes);
-    const sequenced = this._emitTouchedBranchOrder(
-      withOrder ?? withFilter ?? changes
+    const sequenced = this._emitTouchedBranchOrder(withFilter ?? changes);
+    const withOrder = this._reapplyActiveOrder(
+      sequenced.changes ?? withFilter ?? changes,
+      sequenced.touchedParents
+    );
+    const reapplied = withOrder ?? sequenced.changes ?? withFilter;
+    const finalChanges = reapplied ?? changes;
+    const createdIds = finalChanges.activities.filter((change) => change.kind === "created").map((change) => String(change.id));
+    if (createdIds.length === 0) return reapplied;
+    const createdAndAncestors = new Set(createdIds);
+    const filterProjection = this.coreRuntime.state.getFilterProjection();
+    for (const createdId of createdIds) {
+      if (filterProjection !== null) {
+        filterProjection.pinnedVisibleIds.add(createdId);
+      }
+      let activityId = createdId;
+      while (activityId !== null && activityId !== ROOT_PARENT_ID) {
+        createdAndAncestors.add(activityId);
+        if (filterProjection !== null) {
+          filterProjection.visibleIds.add(activityId);
+          filterProjection.visibleReferenceCounts.set(
+            activityId,
+            (filterProjection.visibleReferenceCounts.get(activityId) ?? 0) + 1
+          );
+        }
+        activityId = this.coreRuntime.state.getParentId(activityId);
+      }
+    }
+    const createdVisibility = applyVisibleSet(
+      this.coreRuntime.state,
+      createdAndAncestors,
+      createdAndAncestors
     );
-    return sequenced ?? withOrder ?? withFilter;
+    if (createdVisibility.length === 0) return reapplied;
+    return {
+      ...finalChanges,
+      viewState: [...finalChanges.viewState ?? [], ...createdVisibility]
+    };
   }
   /**
    * Emits `order` for the branches this mutation resequenced, when no user order
@@ -18935,18 +20087,19 @@ var ScheduleCore = class {
    */
   _emitTouchedBranchOrder(changes) {
     const adapter = this.coreRuntime.state;
-    if (adapter.getActiveOrder() !== null) return null;
-    const touched = collectResequencedParents(
+    const touchedParents = collectResequencedParents(
       changes,
       (activityId) => adapter.getParentId(activityId)
     );
-    if (touched.size === 0) return null;
-    const order = [...touched].map((parentId) => ({
-      parentId,
-      childIds: getChildrenInVisualOrder(parentId, adapter)
-    })).filter((branch) => branch.childIds.length > 1);
-    if (order.length === 0) return null;
-    return { ...changes, order };
+    if (adapter.getActiveOrder() !== null) {
+      return { changes: null, touchedParents };
+    }
+    if (touchedParents.size === 0) {
+      return { changes: null, touchedParents };
+    }
+    const order = collectBranchOrderForParents(adapter, touchedParents);
+    if (order.length === 0) return { changes: null, touchedParents };
+    return { changes: { ...changes, order }, touchedParents };
   }
   /**
    * Re-sequences the grid after any mutation that could have changed a value the
@@ -18957,23 +20110,63 @@ var ScheduleCore = class {
    * Production only re-sorts after a bar drag; diverging from that is a
    * deliberate product decision, not an oversight.
    */
-  _reapplyActiveOrder(changes) {
+  _reapplyActiveOrder(changes, resequencedParents) {
     const adapter = this.coreRuntime.state;
     if (adapter.getActiveOrder() === null) return null;
     adapter.invalidateDerivedOrder();
-    return { ...changes, order: collectBranchOrder(adapter) };
+    const hasIndirectOrderChanges = changes.links.length > 0 || changes.calendars.length > 0;
+    if (hasIndirectOrderChanges) {
+      return { ...changes, order: collectBranchOrder(adapter) };
+    }
+    const affectedParents = new Set(resequencedParents);
+    for (const change of changes.activities) {
+      if (change.kind === "deleted") {
+        return { ...changes, order: collectBranchOrder(adapter) };
+      }
+      const parentId = adapter.getParentId(change.id);
+      affectedParents.add(
+        parentId === null ? ROOT_PARENT_ID : String(parentId)
+      );
+    }
+    const order = collectBranchOrderForParents(adapter, affectedParents);
+    if (order.length === 0) return null;
+    return { ...changes, order };
   }
   _reapplyActiveFilter(changes) {
-    const filter = this.coreRuntime.state.getActiveFilter();
-    if (filter === null) return null;
     const adapter = this.coreRuntime.state;
-    const visibleIds = evaluateVisibleIds({
-      activities: adapter.getAllActivities(),
-      parentOf: (activityId) => adapter.getParentId(activityId),
+    const filter = adapter.getActiveFilter();
+    if (filter === null) return null;
+    const context = buildFilterContext(this.coreRuntime.sector.hoursPerDay);
+    const projection = adapter.getFilterProjection();
+    const projectionIsCurrent = isCurrentFilterProjection(
+      projection,
       filter,
-      context: buildFilterContext(this.coreRuntime.sector.hoursPerDay)
-    });
-    const viewState = applyVisibleSet(adapter, visibleIds);
+      context
+    );
+    const changedActivities = changesRequireFilterProjectionRebuild(changes) ? null : collectChangedActivities(changes, adapter);
+    let affectedIds;
+    let visibleIds;
+    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent;
+    if (needsProjectionRebuild) {
+      const rebuiltProjection = buildFilterProjection({
+        activities: adapter.getAllActivities(),
+        parentOf: (activityId) => adapter.getParentId(activityId),
+        filter,
+        context,
+        ...projectionIsCurrent ? { pinnedVisibleIds: projection.pinnedVisibleIds } : {}
+      });
+      adapter.setFilterProjection(rebuiltProjection);
+      visibleIds = rebuiltProjection.visibleIds;
+      affectedIds = adapter.getAllIds();
+    } else {
+      affectedIds = updateFilterProjection(
+        projection,
+        changedActivities,
+        (activityId) => adapter.getParentId(activityId)
+      );
+      visibleIds = projection.visibleIds;
+    }
+    const viewState = applyVisibleSet(adapter, visibleIds, affectedIds);
     if (viewState.length === 0) return null;
     return {
       ...changes,
@@ -18982,6 +20175,10 @@ var ScheduleCore = class {
   }
   _recordScheduleMutation(criticalPathIsFresh) {
     this._scheduleRevision++;
+    this._pendingScheduleRevision = Math.max(
+      this._pendingScheduleRevision,
+      this._scheduleRevision
+    );
     if (this._activeCriticalPath) {
       this._activeCriticalPath.cancellation.cancelled = true;
     }
@@ -19012,23 +20209,30 @@ var ScheduleCore = class {
         this.coreRuntime.baseCalendars
       )
     );
-    const isCurrent = () => !cancellation.cancelled && this._status !== SCHEDULE_CORE_STATUS.DESTROYED && this._scheduleRevision === revision;
+    const isCurrent = () => !cancellation.cancelled && this._status !== SCHEDULE_CORE_STATUS.DESTROYED && this._scheduleRevision === revision && // A mutation admitted but not yet settled is enough to make this result
+    // garbage. Without this term the calculation only learns it is obsolete
+    // when the mutation finishes, which measured live is the same instant the
+    // job itself ends.
+    this._pendingScheduleRevision === this._scheduleRevision;
     const promise = (async () => {
       const calculatedFields = await computeCriticalPathFields(
         isolatedState,
         this.coreRuntime.sector.hoursPerDay,
         isCurrent
       );
-      if (!isCurrent()) return null;
-      const fieldsByActivity = calculatedFields ?? /* @__PURE__ */ new Map();
+      if (!isCurrent() || calculatedFields === null) return null;
       return this._enqueue(async () => {
         if (!isCurrent()) return null;
         this.coreRuntime.state.beginWriteCapture();
         this.coreRuntime.customIdTracker.beginCustomIdTransaction();
         let changes;
         try {
-          for (const [activityId, fields] of fieldsByActivity) {
-            this.coreRuntime.state.setActivityFields(activityId, fields);
+          for (const [activityId, fields] of calculatedFields) {
+            setCriticalPathFieldsIfChanged(
+              this.coreRuntime.state,
+              activityId,
+              fields
+            );
           }
           changes = await assembleChangeSet(this.coreRuntime.state, {
             source: { kind: "init" },
@@ -19090,47 +20294,17 @@ var ScheduleCore = class {
     }
     return { changes };
   }
-  _recomputeAfterHistoryRestore() {
-    const state = this.coreRuntime.state;
-    recomputeAllProgressRollup(state);
-    recomputeCanonicalRealWork(state);
-    emitRealCost(state);
-    if (this.coreRuntime.clock) {
-      const now = endOfLocalDay(this.coreRuntime.clock());
-      applyExpectedProgressLive(state, now);
-      let hasActiveBaseline2 = false;
-      state.forEachActivity((activity) => {
-        hasActiveBaseline2 ||= getActiveBaseline(activity) !== null;
-      });
-      if (hasActiveBaseline2) {
-        runExpectedProgressBase(
-          state,
-          now,
-          this.coreRuntime.baseCalendars.find(
-            (calendar) => calendar.baseDefault
-          )?.id ?? null
-        );
-      }
-      applyStatusPass(state, this.coreRuntime.sector.statusCriteria);
-    }
-  }
   undo(options = {}) {
+    const admitted = this._admitScheduleMutation();
+    let changedState = false;
     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);
-      this._undo.resetCoalesce();
-      const changes = buildInverseChangeSet(
-        this.coreRuntime.state,
-        entry,
-        "before"
-      );
-      return this._reapplyViewState(changes) ?? changes;
+      try {
+        return await this._runUndo(options, (changed) => {
+          changedState = changed;
+        });
+      } finally {
+        this._settleScheduleMutation(admitted, changedState);
+      }
     });
     void operation.then(
       (changes) => {
@@ -19147,23 +20321,45 @@ var ScheduleCore = class {
     );
     return operation;
   }
-  redo(options = {}) {
-    const operation = this._enqueue(async () => {
+  async _runUndo(options, markChanged) {
+    {
       this.assertReady();
-      const entry = this._undo.takeRedo();
+      if (options.expectedUndoDepth !== void 0 && this._undo.undoDepth() !== options.expectedUndoDepth) {
+        return null;
+      }
+      const entry = this._undo.takeUndo();
       if (!entry) return null;
-      applyRedo(this.coreRuntime.state, entry);
-      this._recomputeAfterHistoryRestore();
+      applyUndo(this.coreRuntime.state, entry);
       this._recordScheduleMutation(false);
+      markChanged(true);
       if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
-      this._undo.pushUndo(entry);
+      this._undo.pushRedo(entry);
       this._undo.resetCoalesce();
       const changes = buildInverseChangeSet(
         this.coreRuntime.state,
         entry,
-        "after"
+        "before"
+      );
+      this._saveTracker.recordChanges(
+        changes.activities,
+        changes.links,
+        (activityId) => this.coreRuntime.state.getActivity(activityId),
+        (linkId) => this.coreRuntime.state.getLink(linkId)
       );
       return this._reapplyViewState(changes) ?? changes;
+    }
+  }
+  redo(options = {}) {
+    const admitted = this._admitScheduleMutation();
+    let changedState = false;
+    const operation = this._enqueue(async () => {
+      try {
+        return await this._runRedo((changed) => {
+          changedState = changed;
+        });
+      } finally {
+        this._settleScheduleMutation(admitted, changedState);
+      }
     });
     void operation.then(
       (changes) => {
@@ -19180,6 +20376,29 @@ var ScheduleCore = class {
     );
     return operation;
   }
+  async _runRedo(markChanged) {
+    this.assertReady();
+    const entry = this._undo.takeRedo();
+    if (!entry) return null;
+    applyRedo(this.coreRuntime.state, entry);
+    this._recordScheduleMutation(false);
+    markChanged(true);
+    if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
+    this._undo.pushUndo(entry);
+    this._undo.resetCoalesce();
+    const changes = buildInverseChangeSet(
+      this.coreRuntime.state,
+      entry,
+      "after"
+    );
+    this._saveTracker.recordChanges(
+      changes.activities,
+      changes.links,
+      (activityId) => this.coreRuntime.state.getActivity(activityId),
+      (linkId) => this.coreRuntime.state.getLink(linkId)
+    );
+    return this._reapplyViewState(changes) ?? changes;
+  }
   canUndo() {
     return this._undo.canUndo();
   }
@@ -19220,10 +20439,17 @@ var ScheduleCore = class {
       );
     }
   }
-  _rollback() {
+  _rollback(generatorSnapshot) {
     try {
       this.coreRuntime.state.restoreFromCapture();
       this.coreRuntime.customIdTracker.rollbackCustomIdTransaction();
+      if (generatorSnapshot) {
+        this.coreRuntime.activityIdGenerator.restore(generatorSnapshot[0]);
+        this.coreRuntime.linkIdGenerator.restore(generatorSnapshot[1]);
+        this.coreRuntime.uniqueCorrelativeIdGenerator.restore(
+          generatorSnapshot[2]
+        );
+      }
     } catch (restoreError) {
       this._status = SCHEDULE_CORE_STATUS.POISONED;
       this.coreRuntime.reporter.error(
@@ -19243,18 +20469,6 @@ function toPublicDispatchResult(result) {
   return publicResult;
 }
 
-// src/boundary/save/link-changes.ts
-function checkNoUpdatedLinks(baseline, current) {
-  const baselineById = new Map(
-    baseline.map((link) => [String(link.id), link])
-  );
-  return current.filter((link) => {
-    const base = baselineById.get(String(link.id));
-    if (!base) return false;
-    return base.lag !== link.lag || base.type !== link.type;
-  });
-}
-
 // src/boundary/save/unsaved.ts
 var getUnsavedActivities = (activities = []) => (activities ?? []).filter((activity) => !activity.proplannerId);