@outbuild-company/schedule-core 1.26.0 → 1.26.1

package/dist/index.cjs

@@ -1,16 +1,5 @@
 'use strict';
 
-// src/activity-types/constants.ts
-var ACTIVITY_TYPE = {
-  TASK: "task",
-  PROJECT: "project",
-  MILESTONE: "milestone"
-};
-var ACTIVITY_TYPES = Object.values(ACTIVITY_TYPE);
-function isActivityType(value) {
-  return ACTIVITY_TYPES.includes(value);
-}
-
 // src/types.ts
 var NOTIFICATION_TYPE = {
   CONSTRAINT: "constraint"};
@@ -692,7 +681,10 @@ function createLinksApi(engine) {
 }
 function createScheduleNamespaces(engine) {
   const applyBaselinePoints2 = (points, options) => engine.dispatch(
-    { kind: DISPATCH_ACTION_KIND.BASELINE_APPLY, points },
+    {
+      kind: DISPATCH_ACTION_KIND.BASELINE_APPLY,
+      points
+    },
     options
   );
   return {
@@ -1076,6 +1068,17 @@ function dispatchVisibilitySet(action, deps) {
   return { ok: true, changes };
 }
 
+// src/activity-types/constants.ts
+var ACTIVITY_TYPE = {
+  TASK: "task",
+  PROJECT: "project",
+  MILESTONE: "milestone"
+};
+var ACTIVITY_TYPES = Object.values(ACTIVITY_TYPE);
+function isActivityType(value) {
+  return ACTIVITY_TYPES.includes(value);
+}
+
 // src/autoscheduler/constants.ts
 var TIMING = {
   YIELD_SLICE_MS: 8
@@ -2442,6 +2445,7 @@ var ACTIVITY_PROPERTY = {
   DURATION_HOURS: "durationHours",
   CONSTRAINT_TYPE: "constraintType",
   CONSTRAINT_DATE: "constraintDate",
+  CALENDAR_ID: "calendarId",
   PROGRESS: "progress",
   COST: "cost",
   USED_COST: "usedCost",
@@ -2572,6 +2576,17 @@ function filterTopoOrder(order, scopedIds) {
   return filtered;
 }
 
+// src/constants/progress.ts
+var NOT_STARTED_PROGRESS = 0;
+var COMPLETED_PROGRESS = 100;
+var MAX_TOLERATED_PROGRESS = COMPLETED_PROGRESS + Number.EPSILON * COMPLETED_PROGRESS * 2;
+function isCompletedProgress(progress) {
+  return progress >= COMPLETED_PROGRESS && progress <= MAX_TOLERATED_PROGRESS;
+}
+function isAutoSchedulingEnabledForProgress(progress) {
+  return progress === NOT_STARTED_PROGRESS;
+}
+
 // src/autoscheduler/utils/parent-link-expansion.ts
 function isSummary2(id, adapter) {
   const activity = adapter.getActivity(id);
@@ -2751,12 +2766,8 @@ function deriveSummaryBoundsWithDates(summaryId, adapter, resolveDates) {
   if (earliestStart === null || latestEnd === null) return null;
   return { startDate: earliestStart, endDate: latestEnd };
 }
-function deriveSummaryBounds(summaryId, adapter) {
-  return deriveSummaryBoundsWithDates(summaryId, adapter, (leafId) => {
-    const leaf = adapter.getActivity(leafId);
-    if (!leaf) return null;
-    return { startDate: leaf.startDate, endDate: leaf.endDate };
-  });
+function deriveSummaryBounds(summaryId, adapter, resolveDates = (leafId) => adapter.getActivity(leafId)) {
+  return deriveSummaryBoundsWithDates(summaryId, adapter, resolveDates);
 }
 function endpointSpanHours(endpoint, bounds, adapter) {
   if (!endpoint) return 0;
@@ -2782,31 +2793,48 @@ function hasIncomingRawLink(leafId, linksByActivity) {
   const bucket = linksByActivity.get(leafKey) ?? [];
   return bucket.some((rawLink) => String(rawLink.target) === leafKey);
 }
-function targetOffsetForLeaf(leafId, targetStart, source, adapter, linksByActivity) {
-  if (hasIncomingRawLink(leafId, linksByActivity)) return 0;
+function targetOffsetForLeaf(leafId, targetStart, adapter, linksByActivity, targetEndpointIsFinish) {
+  if (!targetEndpointIsFinish && hasIncomingRawLink(leafId, linksByActivity))
+    return 0;
   const leaf = adapter.getActivity(leafId);
-  if (!targetStart || !leaf || !source) return 0;
+  if (!targetStart || !leaf) return 0;
   return adapter.calculateDuration({
     startDate: targetStart,
     endDate: leaf.startDate,
-    task: source
+    task: leaf
   });
 }
 function resolveExpansionAnchors(originalLink, adapter) {
   const source = adapter.getActivity(originalLink.source);
   const target = adapter.getActivity(originalLink.target);
   const sourceBounds = deriveSummaryBounds(originalLink.source, adapter);
-  const targetBounds = deriveSummaryBounds(originalLink.target, adapter);
+  const fullTargetBounds = deriveSummaryBounds(originalLink.target, adapter);
+  const targetBounds = deriveSummaryBoundsWithDates(
+    originalLink.target,
+    adapter,
+    (leafId) => {
+      const leaf = adapter.getActivity(leafId);
+      if (!leaf) return null;
+      const hasFixedDate = leaf.constraintDate !== null && (leaf.constraintType === CONSTRAINT_TYPE.MSO || leaf.constraintType === CONSTRAINT_TYPE.MFO);
+      const canSchedule = leaf.autoScheduling && leaf.progress !== COMPLETED_PROGRESS && !hasFixedDate;
+      if (!canSchedule) return null;
+      return { startDate: leaf.startDate, endDate: leaf.endDate };
+    }
+  );
   const sourceEndpointIsStart = originalLink.type === LINK_TYPE.START_TO_START || originalLink.type === LINK_TYPE.START_TO_FINISH;
   const targetEndpointIsFinish = originalLink.type === LINK_TYPE.FINISH_TO_FINISH || originalLink.type === LINK_TYPE.START_TO_FINISH;
   return {
     source,
     sourceBounds,
     targetStart: targetBounds?.startDate ?? target?.startDate,
+    targetBounds,
+    hasFrozenTargetStart: Boolean(
+      fullTargetBounds && targetBounds && fullTargetBounds.startDate < targetBounds.startDate
+    ),
+    targetEndpointIsFinish,
     userLag: originalLink.lag ?? 0,
     sourceEndpointIsStart,
-    targetLag: targetEndpointIsFinish ? -endpointSpanHours(target, targetBounds, adapter) : 0,
-    summarySourceId: originalLink.type === LINK_TYPE.START_TO_START && sourceBounds ? originalLink.source : void 0,
+    summarySourceId: sourceEndpointIsStart && sourceBounds ? originalLink.source : void 0,
     finishAnchoredSummaryTargetId: targetEndpointIsFinish && targetBounds ? originalLink.target : void 0
   };
 }
@@ -2815,7 +2843,9 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
   const { source, sourceBounds, targetStart, userLag } = anchors;
   const {
     sourceEndpointIsStart,
-    targetLag,
+    targetBounds,
+    targetEndpointIsFinish,
+    hasFrozenTargetStart,
     summarySourceId,
     finishAnchoredSummaryTargetId
   } = anchors;
@@ -2824,12 +2854,13 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
     const sourceLag = sourceEndpointIsStart ? sourceLagForLeaf(srcId, source, sourceBounds, adapter) : 0;
     for (const tgtId of leafIds) {
       if (String(srcId) === String(tgtId)) continue;
+      const targetLag = targetEndpointIsFinish ? -endpointSpanHours(adapter.getActivity(tgtId), targetBounds, adapter) : 0;
       const offTarget = targetOffsetForLeaf(
         tgtId,
         targetStart,
-        source,
         adapter,
-        linksByActivity
+        linksByActivity,
+        targetEndpointIsFinish
       );
       expanded.push(
         buildVirtualLink(
@@ -2841,7 +2872,8 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
           targetLag,
           userLag + offTarget,
           summarySourceId,
-          finishAnchoredSummaryTargetId ?? (offTarget !== 0 && targetLag === 0 ? originalLink.target : void 0)
+          finishAnchoredSummaryTargetId ?? ((offTarget !== 0 || hasFrozenTargetStart) && targetLag === 0 ? originalLink.target : void 0),
+          targetBounds ? originalLink.target : void 0
         )
       );
       counter += 1;
@@ -2849,7 +2881,7 @@ function pushOffsetPreservingLinks(expanded, sourceIds, leafIds, originalLink, a
   }
   return counter;
 }
-function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, trueLag, summarySourceId, offsetSummaryTargetId) {
+function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag, targetLag, trueLag, summarySourceId, offsetSummaryTargetId, lagActivityId) {
   return {
     id: `virtual_${originalLink.id}_${counter}`,
     source: sourceId,
@@ -2858,6 +2890,7 @@ function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag,
     lag: originalLink.lag,
     freeSlackHours: null,
     isCritical: false,
+    ...lagActivityId === void 0 ? {} : { _lagActivityId: lagActivityId },
     _sourceLag: sourceLag,
     _targetLag: targetLag,
     _trueLag: trueLag,
@@ -2928,17 +2961,6 @@ function findConnectedGroupForTrigger(triggerId, links) {
   return { activityIds, links: groupLinks };
 }
 
-// src/constants/progress.ts
-var NOT_STARTED_PROGRESS = 0;
-var COMPLETED_PROGRESS = 100;
-var MAX_TOLERATED_PROGRESS = COMPLETED_PROGRESS + Number.EPSILON * COMPLETED_PROGRESS * 2;
-function isCompletedProgress(progress) {
-  return progress >= COMPLETED_PROGRESS && progress <= MAX_TOLERATED_PROGRESS;
-}
-function isAutoSchedulingEnabledForProgress(progress) {
-  return progress === NOT_STARTED_PROGRESS;
-}
-
 // src/autoscheduler/engine/link-calculator.ts
 var MILLISECONDS_PER_HOUR = 36e5;
 var INSTANT_MILLISECONDS = 1;
@@ -3016,11 +3038,15 @@ function normalize(predecessor, successor, link) {
       };
   }
 }
-function summaryAnchoredSourceLag(link, predecessor, adapter) {
+function summaryAnchoredSourceLag(link, predecessor, adapter, resolveDates) {
   if (link._summarySourceId === void 0) return null;
   const summarySource = adapter.getActivity(link._summarySourceId);
   if (!summarySource) return null;
-  const summaryBounds = deriveSummaryBounds(link._summarySourceId, adapter);
+  const summaryBounds = deriveSummaryBounds(
+    link._summarySourceId,
+    adapter,
+    resolveDates
+  );
   if (!summaryBounds) return null;
   return -adapter.calculateDuration({
     startDate: summaryBounds.startDate,
@@ -3065,7 +3091,7 @@ function reverseRelationshipLagAnchor(successor, relationshipLagTask, adapter) {
     task: relationshipLagTask
   });
 }
-function calculateSuccessorStartFromLink(predecessor, successor, link, adapter, trueLagTask = successor) {
+function calculateSuccessorStartFromLink(predecessor, successor, link, adapter, trueLagTask = successor, resolveDates) {
   const {
     sourceLag: frozenSourceLag,
     targetLag,
@@ -3073,11 +3099,12 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter,
     isFS,
     isFF
   } = normalize(predecessor, successor, link);
-  const sourceLag = summaryAnchoredSourceLag(link, predecessor, adapter) ?? frozenSourceLag;
+  const sourceLag = summaryAnchoredSourceLag(link, predecessor, adapter, resolveDates) ?? frozenSourceLag;
+  const lagActivity = link._lagActivityId === void 0 ? null : adapter.getActivity(link._lagActivityId);
   const totalLag = sourceLag + targetLag + trueLag;
   const isZeroDurationSuccessor = successor.durationHours === 0;
   const hasLag = isZeroDurationSuccessor ? totalLag !== 0 : sourceLag !== 0 || targetLag !== 0 || trueLag !== 0;
-  if (!hasLag) {
+  if (!hasLag && (!lagActivity || isZeroDurationSuccessor && sourceLag === 0 && targetLag === 0 && trueLag === 0)) {
     return noLagSuccessorStart(
       predecessor,
       successor,
@@ -3086,7 +3113,7 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter,
       isFS || isFF
     );
   }
-  const baseTask = isFS ? successor : predecessor;
+  const baseTask = isFS ? lagActivity ?? successor : predecessor;
   let date2 = relationshipLagAnchor(predecessor, baseTask, trueLagTask, adapter);
   if (sourceLag !== 0) {
     date2 = adapter.calculateEndDate({
@@ -3095,15 +3122,30 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter,
       task: predecessor
     });
   }
-  if (targetLag !== 0) {
-    date2 = adapter.calculateEndDate({
-      startDate: date2,
-      durationHours: targetLag,
-      task: successor
+  if (lagActivity) {
+    date2 = addTrueLag(date2, link.lag ?? 0, lagActivity, adapter);
+    date2 = adapter.getClosestWorkTime({
+      date: date2,
+      dir: isFS || link.type === LINK_TYPE.START_TO_START ? "future" : "past",
+      task: lagActivity
     });
-  }
-  if (trueLag !== 0) {
-    date2 = addTrueLag(date2, trueLag, trueLagTask, adapter);
+    const leafOffset = targetLag + trueLag - (link.lag ?? 0);
+    if (leafOffset !== 0) {
+      date2 = adapter.calculateEndDate({
+        startDate: date2,
+        durationHours: leafOffset,
+        task: successor
+      });
+    }
+  } else {
+    if (targetLag !== 0) {
+      date2 = adapter.calculateEndDate({
+        startDate: date2,
+        durationHours: targetLag,
+        task: successor
+      });
+    }
+    if (trueLag !== 0) date2 = addTrueLag(date2, trueLag, trueLagTask, adapter);
   }
   if (successor.durationHours === 0) {
     if (isFS || isFF) {
@@ -3143,16 +3185,25 @@ function calculatePredecessorEndFromLink(successor, predecessor, link, adapter,
     successor,
     link
   );
-  let date2 = reverseRelationshipLagAnchor(successor, trueLagTask, adapter);
-  if (trueLag !== 0) {
-    date2 = addTrueLag(date2, -trueLag, trueLagTask, adapter);
-  }
-  if (targetLag !== 0) {
-    date2 = adapter.calculateEndDate({
-      startDate: date2,
-      durationHours: -targetLag,
-      task: successor
-    });
+  const lagActivity = link._lagActivityId === void 0 ? null : adapter.getActivity(link._lagActivityId);
+  let date2 = lagActivity ? new Date(successor.startDate) : reverseRelationshipLagAnchor(successor, trueLagTask, adapter);
+  if (lagActivity) {
+    const leafOffset = targetLag + trueLag - (link.lag ?? 0);
+    if (leafOffset !== 0)
+      date2 = adapter.calculateEndDate({
+        startDate: date2,
+        durationHours: -leafOffset,
+        task: successor
+      });
+    date2 = addTrueLag(date2, -(link.lag ?? 0), lagActivity, adapter);
+  } else {
+    if (trueLag !== 0) date2 = addTrueLag(date2, -trueLag, trueLagTask, adapter);
+    if (targetLag !== 0)
+      date2 = adapter.calculateEndDate({
+        startDate: date2,
+        durationHours: -targetLag,
+        task: successor
+      });
   }
   if (sourceLag !== 0) {
     date2 = adapter.calculateEndDate({
@@ -3254,8 +3305,71 @@ function shouldSkipLagForMultiDrag(predecessorId, flags, draggedIds) {
   return flags.dragWithMultiple && isPredecessorBeingDragged(predecessorId, draggedIds);
 }
 
+// src/autoscheduler/engine/summary-finish-groups.ts
+function collectSummaryFinishGroups(links, adapter, resolveDates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    if (link.type !== LINK_TYPE.FINISH_TO_FINISH && link.type !== LINK_TYPE.START_TO_FINISH)
+      continue;
+    const summaryId = link._summaryTargetId;
+    if (summaryId === void 0) continue;
+    if (groups.has(summaryId)) continue;
+    let independentlyDriven = false;
+    const starts = /* @__PURE__ */ new Map();
+    let movableEnd = null;
+    let movableLeafId = null;
+    const bounds = deriveSummaryBounds(summaryId, adapter, (id) => {
+      const leaf = adapter.getActivity(id);
+      if (!leaf) return null;
+      const dates = resolveDates(id);
+      starts.set(id, dates.startDate);
+      if (!leaf.autoScheduling || leaf.progress === COMPLETED_PROGRESS || leaf.constraintType !== CONSTRAINT_TYPE.ASAP)
+        independentlyDriven = true;
+      for (const linkId of adapter.getIncomingLinkIds(id)) {
+        const incoming = adapter.getLink(linkId);
+        if (incoming && String(incoming.source) !== String(summaryId) && !adapter.isChildOf(incoming.source, summaryId))
+          independentlyDriven = true;
+      }
+      const hasFixedDate = leaf.constraintDate !== null && (leaf.constraintType === CONSTRAINT_TYPE.MSO || leaf.constraintType === CONSTRAINT_TYPE.MFO);
+      const movable = leaf.autoScheduling && leaf.progress !== COMPLETED_PROGRESS && !hasFixedDate;
+      if (movable && (movableEnd === null || dates.endDate > movableEnd || dates.endDate.getTime() === movableEnd.getTime() && id < (movableLeafId ?? id))) {
+        movableEnd = dates.endDate;
+        movableLeafId = id;
+      }
+      return dates;
+    });
+    const drivingLeafIds = /* @__PURE__ */ new Set();
+    const pending = movableLeafId === null ? [] : [movableLeafId];
+    while (pending.length > 0) {
+      const id = pending.pop();
+      if (drivingLeafIds.has(id)) continue;
+      drivingLeafIds.add(id);
+      for (const linkId of [
+        ...adapter.getIncomingLinkIds(id),
+        ...adapter.getOutgoingLinkIds(id)
+      ]) {
+        const link2 = adapter.getLink(linkId);
+        if (!link2) continue;
+        const neighbor = String(link2.source) === String(id) ? link2.target : link2.source;
+        if (starts.has(neighbor) && !drivingLeafIds.has(neighbor))
+          pending.push(neighbor);
+      }
+    }
+    groups.set(
+      summaryId,
+      independentlyDriven && bounds ? {
+        endDate: bounds.endDate,
+        movableEnd,
+        starts,
+        drivingLeafIds
+      } : null
+    );
+  }
+  return groups;
+}
+
 // src/autoscheduler/engine/asap-pass.ts
-async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
+async function asapPass(orderedIds, links, adapter, options, isCurrent, plans, deferSummaryFinishes = false) {
   const incomingLinks = /* @__PURE__ */ new Map();
   for (const link of links) {
     const key = String(link.target);
@@ -3271,6 +3385,11 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
     if (snap) return { startDate: snap.startDate, endDate: snap.endDate };
     return { startDate: /* @__PURE__ */ new Date(), endDate: /* @__PURE__ */ new Date() };
   };
+  const summaryFinishes = collectSummaryFinishGroups(
+    links,
+    adapter,
+    getActivityDates
+  );
   const flags = adapter.getFlags();
   const draggedIds = options.draggedIds ?? [];
   let sliceStart = performance.now();
@@ -3307,21 +3426,60 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
         startDate: multiDragDates.startDate,
         endDate: multiDragDates.endDate
       };
-      const effectiveLink = shouldSkipLagForMultiDrag(
+      let effectiveLink = shouldSkipLagForMultiDrag(
         link.source,
         flags,
         draggedIds
       ) ? { ...link, lag: 0 } : link;
+      const summaryFinish = effectiveLink._summaryTargetId === void 0 || effectiveLink.type !== LINK_TYPE.FINISH_TO_FINISH && effectiveLink.type !== LINK_TYPE.START_TO_FINISH ? null : summaryFinishes.get(effectiveLink._summaryTargetId);
+      if (summaryFinish) {
+        if (deferSummaryFinishes) continue;
+        const requiredFinish = calculateSuccessorStartFromLink(
+          adjustedPred,
+          { ...activity, durationHours: 0 },
+          { ...effectiveLink, _targetLag: 0, _trueLag: effectiveLink.lag },
+          adapter,
+          activity,
+          getActivityDates
+        ).successorStart;
+        const lagActivity = adapter.getActivity(effectiveLink._summaryTargetId) ?? activity;
+        const satisfied = summaryFinish.endDate >= requiredFinish || adapter.calculateDuration({
+          startDate: summaryFinish.endDate,
+          endDate: requiredFinish,
+          task: lagActivity
+        }) === 0;
+        if (satisfied || summaryFinish.movableEnd === null || !summaryFinish.drivingLeafIds.has(activityId))
+          continue;
+        effectiveLink = {
+          ...effectiveLink,
+          _targetLag: -adapter.calculateDuration({
+            startDate: summaryFinish.starts.get(activityId) ?? activity.startDate,
+            endDate: summaryFinish.movableEnd,
+            task: activity
+          }),
+          _trueLag: effectiveLink.lag
+        };
+      }
+      let summarySourceMovedThisRun = false;
       const result = calculateSuccessorStartFromLink(
         adjustedPred,
         activity,
         effectiveLink,
-        adapter
+        adapter,
+        activity,
+        (id) => {
+          const dates = getActivityDates(id);
+          const snapshot = adapter.getActivity(id);
+          if (snapshot && (dates.startDate.getTime() !== snapshot.startDate.getTime() || dates.endDate.getTime() !== snapshot.endDate.getTime())) {
+            summarySourceMovedThisRun = true;
+          }
+          return dates;
+        }
       );
       if (!maxStart || result.successorStart > maxStart) {
         maxStart = result.successorStart;
         drivingLinkId = String(link.id);
-        drivingOffsetIsStale = link._summaryTargetId !== void 0 && !predecessorMovedThisRun && (link._targetLag === 0 || options.preventSummaryTargetPullback === true);
+        drivingOffsetIsStale = link._summaryTargetId !== void 0 && !predecessorMovedThisRun && !summarySourceMovedThisRun && (link._targetLag === 0 || options.preventSummaryTargetPullback === true);
       }
     }
     const staleOffsetWouldPullBack = maxStart !== null && drivingOffsetIsStale && maxStart < activity.startDate;
@@ -4552,14 +4710,26 @@ var AutoScheduler = class {
         return { ...emptyResult, cancelled: true };
       }
       const phaseAsap = startPhase("schedule.asapPass");
-      const asapPlans = await asapPass(
+      const hasSummaryFinishLinks = scopedLinks.some(
+        (link) => link._summaryTargetId !== void 0 && (link.type === LINK_TYPE.FINISH_TO_FINISH || link.type === LINK_TYPE.START_TO_FINISH)
+      );
+      const initialAsapPlans = await asapPass(
         topoResult.ordered,
         scopedLinks,
         this.adapter,
         options,
         isCurrent,
-        plans
+        plans,
+        hasSummaryFinishLinks
       );
+      const asapPlans = hasSummaryFinishLinks ? await asapPass(
+        topoResult.ordered,
+        scopedLinks,
+        this.adapter,
+        options,
+        isCurrent,
+        initialAsapPlans
+      ) : initialAsapPlans;
       endPhase(phaseAsap);
       if ((await yieldBetweenPhases(isCurrent)).aborted) {
         return { ...emptyResult, cancelled: true };
@@ -4721,14 +4891,16 @@ function roundProgressPerLevel(value) {
 }
 
 // src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
+function recomputeAllProgressRollup(adapter, criterion) {
+  const zeroCostBasis = /* @__PURE__ */ new Map();
   for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
+    rollupParent(parentId, adapter, criterion, zeroCostBasis);
   }
 }
-function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
+function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter, criterion) {
+  const zeroCostBasis = /* @__PURE__ */ new Map();
   for (const parentId of parentIdsDeepestFirst) {
-    rollupParent(parentId, adapter);
+    rollupParent(parentId, adapter, criterion, zeroCostBasis);
   }
 }
 function parentsDeepestFirst(adapter) {
@@ -4752,7 +4924,7 @@ function depthOf(id, adapter) {
   }
   return depth;
 }
-function rollupParent(parentId, adapter) {
+function rollupParent(parentId, adapter, criterion, zeroCostBasis) {
   const childIds = adapter.getChildren(parentId);
   if (childIds.length === 0) return;
   const children = [];
@@ -4764,12 +4936,20 @@ function rollupParent(parentId, adapter) {
       ponderator: Number(child.ponderator ?? 0)
     });
   }
-  applyWeightedProgressRollup(parentId, children, adapter);
+  applyWeightedProgressRollup(
+    parentId,
+    children,
+    adapter,
+    criterion,
+    zeroCostBasis
+  );
 }
-function applyWeightedProgressRollup(parentId, children, adapter) {
+function applyWeightedProgressRollup(parentId, children, adapter, criterion, zeroCostBasis = /* @__PURE__ */ new Map()) {
   const parent = adapter.getActivity(parentId);
   if (!parent) return;
-  const rollup = computeWeightedProgressRollup(children);
+  const weightedProgress = computeWeightedProgressRollup(children);
+  const hasZeroCostBasis = weightedProgress === null && criterion === ACTIVITY_PONDERATOR_CRITERION.COST && hasOnlyZeroBaselineCosts(parentId, adapter, zeroCostBasis) === true;
+  const rollup = hasZeroCostBasis ? 0 : weightedProgress;
   if (rollup === null) {
     const fallback = adapter.getProgressFallback(parentId);
     if (fallback !== null) {
@@ -4786,6 +4966,43 @@ function applyWeightedProgressRollup(parentId, children, adapter) {
     roundProgressPerLevel(rollup)
   );
 }
+function hasOnlyZeroBaselineCosts(parentId, adapter, zeroCostBasis) {
+  const pending = [...adapter.getChildren(parentId)];
+  let hasBaseline = false;
+  while (pending.length > 0) {
+    const activityId = pending.pop();
+    const cachedBasis = zeroCostBasis.get(activityId);
+    if (cachedBasis === false) {
+      zeroCostBasis.set(parentId, false);
+      return false;
+    }
+    if (cachedBasis !== void 0) {
+      hasBaseline ||= cachedBasis === true;
+      continue;
+    }
+    const activity = adapter.getActivity(activityId);
+    if (!activity) continue;
+    const children = adapter.getChildren(activityId);
+    if (children.length > 0) {
+      pending.push(...children);
+      continue;
+    }
+    const basis2 = zeroBaselineCost(activity);
+    hasBaseline ||= basis2 !== null;
+    if (basis2 === false) {
+      zeroCostBasis.set(parentId, false);
+      return false;
+    }
+  }
+  const basis = hasBaseline ? true : null;
+  zeroCostBasis.set(parentId, basis);
+  return basis;
+}
+function zeroBaselineCost(activity) {
+  const baseline = getActiveBaseline(activity);
+  if (!baseline) return null;
+  return activity.type === ACTIVITY_TYPE.MILESTONE || baseline.cost === 0;
+}
 function setExplicitSummaryProgressFallbacks(activityId, progress, adapter) {
   const pending = [activityId];
   while (pending.length > 0) {
@@ -4812,7 +5029,8 @@ async function updateParentBoundsFromChildren(adapter, dirtyIds, recomputeProgre
   const parents = dirtyIds ? findAncestorsOfDirty(adapter, dirtyIds) : findAllParents(adapter);
   const progressMode = recomputeProgress ? options.progressMode ?? PARENT_PROGRESS_MODE.FREEZE_WITHOUT_CONTRIBUTION : PARENT_PROGRESS_MODE.SKIP;
   await recomputeParentsCooperatively(parents, adapter, progressMode, {
-    recomputeRealWork: options.recomputeRealWork ?? false
+    recomputeRealWork: options.recomputeRealWork ?? false,
+    criterion: options.criterion
   });
 }
 function recomputeSingleParentDisplayBounds(parentId, adapter) {
@@ -4821,6 +5039,7 @@ function recomputeSingleParentDisplayBounds(parentId, adapter) {
 async function recomputeParentsCooperatively(parents, adapter, progressMode, options = {
   recomputeRealWork: false
 }) {
+  const zeroCostBasis = /* @__PURE__ */ new Map();
   const YIELD_EVERY_N_PARENTS = 200;
   let processed = 0;
   for (const parentId of parents) {
@@ -4828,7 +5047,9 @@ async function recomputeParentsCooperatively(parents, adapter, progressMode, opt
       parentId,
       adapter,
       progressMode,
-      options.recomputeRealWork
+      options.recomputeRealWork,
+      options.criterion,
+      zeroCostBasis
     );
     processed += 1;
     if (processed % YIELD_EVERY_N_PARENTS === 0) {
@@ -4902,7 +5123,7 @@ function aggregateChildren(childrenIds, adapter, includeRealWork) {
   }
   return { minStart, maxEnd, realWorkSum, weightedChildren };
 }
-function recomputeParentFromChildren(parentId, adapter, progressMode = PARENT_PROGRESS_MODE.FREEZE_WITHOUT_CONTRIBUTION, recomputeRealWork = false) {
+function recomputeParentFromChildren(parentId, adapter, progressMode = PARENT_PROGRESS_MODE.FREEZE_WITHOUT_CONTRIBUTION, recomputeRealWork = false, criterion, zeroCostBasis = /* @__PURE__ */ new Map()) {
   const parent = adapter.getActivity(parentId);
   if (!parent) return;
   const childrenIds = adapter.getChildren(parentId);
@@ -4918,7 +5139,13 @@ function recomputeParentFromChildren(parentId, adapter, progressMode = PARENT_PR
   adapter.setActivityField(parentId, "endDate", newEnd);
   adapter.setActivityField(parentId, "durationHours", durationHours);
   if (progressMode !== PARENT_PROGRESS_MODE.SKIP) {
-    applyWeightedProgressRollup(parentId, aggregate.weightedChildren, adapter);
+    applyWeightedProgressRollup(
+      parentId,
+      aggregate.weightedChildren,
+      adapter,
+      criterion,
+      zeroCostBasis
+    );
   }
   if (recomputeRealWork) {
     adapter.setActivityField(parentId, "realWorkHours", aggregate.realWorkSum);
@@ -5250,9 +5477,13 @@ var POST_PROCESSOR = {
 };
 
 // src/columns/shared/error-codes.ts
+var PARSE_ERROR = {
+  EMPTY_CALENDAR: "empty_calendar"};
 var VALIDATION_REASON = {
   UNCHANGED: "unchanged",
-  NEGATIVE_DURATION: "negative_duration"};
+  NEGATIVE_DURATION: "negative_duration",
+  UNKNOWN_CALENDAR: "unknown_calendar"
+};
 var EDIT_DENIAL_REASON = {
   COMPLETED: "completed",
   SUMMARY: "summary",
@@ -5545,7 +5776,7 @@ var costPipeline = {
   parseInput(rawValue) {
     if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
-    if (Number.isNaN(numericValue)) return parseError("not_a_number");
+    if (!Number.isFinite(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
   },
   validate() {
@@ -5595,7 +5826,7 @@ var usedCostPipeline = {
   parseInput(rawValue) {
     if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
-    if (Number.isNaN(numericValue)) return parseError("not_a_number");
+    if (!Number.isFinite(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
   },
   validate() {
@@ -5648,7 +5879,7 @@ var hhWorkTimePipeline = {
   parseInput(rawValue) {
     if (String(rawValue).trim() === "") return parsed(0, rawValue);
     const numericValue = parseFloat(String(rawValue));
-    if (Number.isNaN(numericValue)) return parseError("not_a_number");
+    if (!Number.isFinite(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
   },
   validate() {
@@ -6046,27 +6277,33 @@ function isUnconstrained(activity) {
 
 // src/columns/calendar-id/calendar-id-pipeline.ts
 var calendarIdPipeline = {
-  targetField: "calendarId",
+  targetField: ACTIVITY_PROPERTY.CALENDAR_ID,
   canEdit() {
     return canEdit();
   },
   parseInput(rawValue) {
+    if (rawValue === null) return parsed(null);
     const value = String(rawValue).trim();
-    if (isEmpty(value)) return parseError("empty_calendar");
+    if (isEmpty(value)) return parseError(PARSE_ERROR.EMPTY_CALENDAR);
     return parsed(value);
   },
   validate(activity, _oldValue, newValue, ctx) {
-    if (isUnchangedCalendar(activity.calendarId, newValue))
-      return invalid("unchanged");
-    if (!ctx.calendars.getCalendar(newValue))
-      return invalid("unknown_calendar");
+    const calendarId = newValue === null ? ctx.getDefaultCalendarId() : newValue;
+    if (isUnchangedCalendar(activity.calendarId, calendarId) && (newValue !== null || activity.assignedDefaultCalendar))
+      return invalid(VALIDATION_REASON.UNCHANGED);
+    if (calendarId === null || !ctx.hasCalendar(calendarId))
+      return invalid(VALIDATION_REASON.UNKNOWN_CALENDAR);
     return valid();
   },
   transform(activity, newValue, ctx) {
-    return fieldChanges(buildCalendarPatch(activity, newValue, ctx), {
-      autoSchedule: true,
-      postProcessors: []
-    });
+    const calendarId = newValue === null ? ctx.getDefaultCalendarId() : newValue;
+    return fieldChanges(
+      buildCalendarPatch(activity, calendarId, newValue === null, ctx),
+      {
+        autoSchedule: true,
+        postProcessors: []
+      }
+    );
   },
   trackEvent: COLUMN_TRACK_EVENT.CALENDAR_ASSIGNMENT
 };
@@ -6076,12 +6313,12 @@ function isEmpty(value) {
 function isUnchangedCalendar(currentId, newId) {
   return currentId === newId;
 }
-function buildCalendarPatch(activity, newCalendarId, ctx) {
+function buildCalendarPatch(activity, newCalendarId, assignedDefaultCalendar, ctx) {
   const fields = {
     calendarId: newCalendarId,
-    assignedDefaultCalendar: false
+    assignedDefaultCalendar
   };
-  const newCalendar = ctx.calendars.getCalendar(newCalendarId);
+  const newCalendar = newCalendarId === null ? null : ctx.calendars.getCalendar(newCalendarId);
   if (newCalendar) {
     const startIsWorking = newCalendar.isWorkTime(activity.startDate, "hour");
     const calendarStart = newCalendar.getClosestWorkTime({
@@ -6291,6 +6528,7 @@ var P6_ACTIVITY_TYPE = {
   TASK: "task",
   LEVEL_OF_EFFORT: "level_of_effort",
   START_MILESTONE: "start_milestone",
+  WBS_SUMMARY: "wbs_summary",
   RESOURCE_DEPENDENT: "resource_dependent"
 };
 var P6_EXECUTION_STATUS = {
@@ -6456,9 +6694,10 @@ var actualStartPipeline = {
   transform(activity, newValue, ctx) {
     if (newValue === null) return actualStartChanges(activity, null);
     const calendar = resolveActivityCalendar(activity, ctx);
+    const firstAssignment = activity.p6?.actualStart == null;
     return actualStartChanges(
       activity,
-      defaultActualStartTime(newValue, calendar)
+      firstAssignment ? defaultActualStartTime(newValue, calendar) : new Date(newValue)
     );
   }
 };
@@ -6467,9 +6706,10 @@ var actualFinishPipeline = {
   transform(activity, newValue, ctx) {
     if (newValue === null) return actualFinishChanges(activity, null);
     const calendar = resolveActivityCalendar(activity, ctx);
+    const firstAssignment = activity.p6?.actualFinish == null;
     return actualFinishChanges(
       activity,
-      defaultActualFinishTime(newValue, calendar)
+      firstAssignment ? defaultActualFinishTime(newValue, calendar) : new Date(newValue)
     );
   }
 };
@@ -12412,7 +12652,7 @@ function collectInsertedIds(captured) {
 }
 
 // src/propagations/downward/recompute-ponderator-for-parent.ts
-function recomputePonderatorsForParent(parentId, criterion, adapter) {
+function recomputePonderatorsForParent(parentId, criterion, adapter, basisById = /* @__PURE__ */ new Map()) {
   if (!parentId || parentId === ROOT_PARENT_ID) return;
   const childIds = adapter.getChildren(parentId);
   if (childIds.length === 0) return;
@@ -12420,15 +12660,21 @@ function recomputePonderatorsForParent(parentId, criterion, adapter) {
   const baselineScopedIds = /* @__PURE__ */ new Set();
   let denominator = 0;
   for (const childId of childIds) {
-    const peso = criterionValue(String(childId), criterion, adapter);
-    pesoById.set(String(childId), peso);
-    denominator += peso;
-    if (hasActiveBaselineInBranch(String(childId), adapter)) {
+    const basis = baselineWeightingBasis(
+      String(childId),
+      criterion,
+      adapter,
+      basisById
+    );
+    pesoById.set(String(childId), basis.magnitude);
+    denominator += basis.magnitude;
+    if (basis.hasActiveBaseline) {
       baselineScopedIds.add(String(childId));
     }
   }
   const relationValue = denominator ? 100 / denominator : 0;
-  const zeroMagnitudeShare = baselineScopedIds.size ? 100 / baselineScopedIds.size : 0;
+  const hasEqualShare = criterion !== ACTIVITY_PONDERATOR_CRITERION.COST && baselineScopedIds.size > 0;
+  const zeroMagnitudeShare = hasEqualShare ? 100 / baselineScopedIds.size : 0;
   for (const childId of childIds) {
     const child = adapter.getActivity(childId);
     if (!child) continue;
@@ -12453,39 +12699,39 @@ function assignedPonderator(childId, child, pesoById, baselineScopedIds, denomin
   }
   return !Array.isArray(child.baselinePoints) || child.baselinePoints.length === 0 ? 0 : null;
 }
-function hasActiveBaselineInBranch(activityId, adapter) {
-  const activity = adapter.getActivity(activityId);
-  if (!activity) return false;
-  if (getActiveBaseline(activity)) return true;
-  if (activity.type !== ACTIVITY_TYPE.PROJECT) return false;
-  return adapter.getChildren(activityId).some((childId) => hasActiveBaselineInBranch(String(childId), adapter));
-}
-function criterionValue(childId, criterion, adapter) {
-  const child = adapter.getActivity(childId);
-  if (!child) return 0;
-  if (child.type === ACTIVITY_TYPE.PROJECT) {
-    return sumRecursiveBaselineMagnitude(childId, criterion, adapter);
-  }
-  const active = getActiveBaseline(child);
-  if (!active) return 0;
-  if (child.type === ACTIVITY_TYPE.MILESTONE) return 0;
-  return baselineMagnitude(active, criterion);
-}
-function sumRecursiveBaselineMagnitude(activityId, criterion, adapter) {
-  let sum2 = 0;
-  for (const childId of adapter.getChildren(activityId)) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    if (child.type === ACTIVITY_TYPE.PROJECT) {
-      sum2 += sumRecursiveBaselineMagnitude(String(childId), criterion, adapter);
+function baselineWeightingBasis(activityId, criterion, adapter, basisById) {
+  const pending = [
+    { id: activityId, expanded: false }
+  ];
+  while (pending.length > 0) {
+    const { id, expanded } = pending.pop();
+    if (basisById.has(id)) continue;
+    const activity = adapter.getActivity(id);
+    const baseline = getActiveBaseline(activity);
+    if (activity?.type !== ACTIVITY_TYPE.PROJECT) {
+      basisById.set(id, {
+        magnitude: baseline && activity?.type !== ACTIVITY_TYPE.MILESTONE ? baselineMagnitude(baseline, criterion) : 0,
+        hasActiveBaseline: baseline !== null
+      });
+      continue;
+    }
+    const children = adapter.getChildren(id);
+    if (!expanded) {
+      pending.push({ id, expanded: true });
+      children.forEach((childId) => {
+        pending.push({ id: String(childId), expanded: false });
+      });
       continue;
     }
-    const active = getActiveBaseline(child);
-    if (active && child.type !== ACTIVITY_TYPE.MILESTONE) {
-      sum2 += baselineMagnitude(active, criterion);
+    const basis = { magnitude: 0, hasActiveBaseline: baseline !== null };
+    for (const childId of children) {
+      const child = basisById.get(String(childId));
+      basis.magnitude += child.magnitude;
+      basis.hasActiveBaseline ||= child.hasActiveBaseline;
     }
+    basisById.set(id, basis);
   }
-  return sum2;
+  return basisById.get(activityId);
 }
 function baselineMagnitude(baseline, criterion) {
   if (criterion === ACTIVITY_PONDERATOR_CRITERION.COST) {
@@ -12501,10 +12747,72 @@ function toNumber(v) {
   return typeof n === "number" && Number.isFinite(n) ? n : 0;
 }
 
+// src/dispatch/shared/structural-ponderators.ts
+function recomputeStructuralPonderators(adapter, criterion) {
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return;
+  const parents = /* @__PURE__ */ new Map();
+  const removedParents = /* @__PURE__ */ new Map();
+  for (const operation of journal.ops) {
+    if (operation.kind === WRITE_OPERATION_KIND.REMOVE) {
+      removedParents.set(operation.activityId, operation.before.parentId);
+    }
+  }
+  const collectParents = (parentId, lostBaseline) => {
+    let current = parentId;
+    while (current !== null && !isRootParent(current)) {
+      const existing = parents.get(current);
+      if (existing === true || existing === lostBaseline) break;
+      parents.set(current, lostBaseline);
+      current = removedParents.has(current) ? removedParents.get(current) ?? null : adapter.getParentId(current);
+    }
+  };
+  for (const [activityId, before] of journal.before) {
+    const after = adapter.getActivity(activityId);
+    const parentChanged = after && before.parentId !== after.parentId;
+    if (!parentChanged || !after) continue;
+    const hasBaseline = getActiveBaseline(before) !== null || hasBaselineInBranch(activityId, adapter);
+    collectParents(before.parentId, hasBaseline);
+    collectParents(after.parentId, false);
+  }
+  for (const operation of journal.ops) {
+    if (operation.kind === WRITE_OPERATION_KIND.REMOVE) {
+      if (getActiveBaseline(operation.before))
+        collectParents(operation.before.parentId, true);
+    } else if (operation.kind === WRITE_OPERATION_KIND.INSERT) {
+      const inserted = adapter.getActivity(operation.activityId);
+      if (inserted && hasBaselineInBranch(inserted.id, adapter))
+        collectParents(inserted.parentId, false);
+    }
+  }
+  for (const [parentId, lostBaseline] of parents) {
+    if (lostBaseline || hasBaselineInBranch(parentId, adapter)) {
+      recomputePonderatorsForParent(parentId, criterion, adapter);
+    }
+  }
+}
+function hasBaselineInBranch(activityId, adapter) {
+  const pending = [activityId];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current === void 0) continue;
+    const activity = adapter.getActivity(current);
+    if (activity && getActiveBaseline(activity)) return true;
+    pending.push(...adapter.getChildren(current));
+  }
+  return false;
+}
+
 // src/dispatch/shared/post-mutation.ts
 var AUTOSCHEDULE_SCOPE = { ROOTS: "roots" };
 async function runPostMutation(deps, args) {
-  recomputePromotedSummaryPonderators(deps);
+  const isConversion = args.action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_CONVERT;
+  if (!isConversion) {
+    recomputeStructuralPonderators(
+      deps.adapter,
+      deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
+    );
+  }
   const progressInvalidation = resolveProgressInvalidation(deps.adapter);
   const effectiveArgs = resolveTransactionAutoscheduleArgs(deps.adapter, args);
   const passes = resolvePasses(
@@ -12525,7 +12833,8 @@ async function runPostMutation(deps, args) {
     effectiveArgs,
     schedule.scheduledIds,
     passes,
-    progressInvalidation
+    progressInvalidation,
+    deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
   );
   await runDerivedRecomputes(deps, passes, args.now);
   synchronizeInactiveDataDateDrafts(deps.adapter);
@@ -12574,37 +12883,6 @@ function collectLinkMutationTargets(adapter) {
   }
   return targets;
 }
-function recomputePromotedSummaryPonderators(deps) {
-  const journal = deps.adapter.peekWriteCapture();
-  if (!journal) return;
-  const visited = /* @__PURE__ */ new Set();
-  const criterion = deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION;
-  for (const [activityId, before] of journal.before) {
-    const after = deps.adapter.getActivity(activityId);
-    if (before.type === ACTIVITY_TYPE.PROJECT || after?.type !== ACTIVITY_TYPE.PROJECT || getActiveBaseline(after) || !hasActiveBaselineDescendant(activityId, deps.adapter)) {
-      continue;
-    }
-    let current = activityId;
-    while (current !== null && !isRootParent(current)) {
-      if (!visited.has(current)) {
-        recomputePonderatorsForParent(current, criterion, deps.adapter);
-        visited.add(current);
-      }
-      current = deps.adapter.getParentId(current);
-    }
-  }
-}
-function hasActiveBaselineDescendant(activityId, adapter) {
-  const pending = [...adapter.getChildren(activityId)];
-  while (pending.length > 0) {
-    const childId = pending.pop();
-    if (childId === void 0) continue;
-    const child = adapter.getActivity(childId);
-    if (child && getActiveBaseline(child)) return true;
-    pending.push(...adapter.getChildren(childId));
-  }
-  return false;
-}
 async function dispatchScheduleAutoSchedule(action, options, deps) {
   if (action.activityId !== void 0 && !deps.adapter.activityExists(action.activityId)) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
@@ -12757,7 +13035,7 @@ async function refreshMutatedParentBounds(adapter, args) {
   if (mutated.size === 0) return;
   await updateParentBoundsFromChildren(adapter, mutated, false);
 }
-async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressInvalidation) {
+async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressInvalidation, criterion) {
   if (passes.has(DERIVED_PASS.PARENT_PROGRESS)) {
     restoreDemotedProgressFallbacks(
       adapter,
@@ -12774,6 +13052,7 @@ async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressI
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
       recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
+      criterion,
       progressMode: "freeze-when-no-contribution"
     }
   );
@@ -13023,6 +13302,8 @@ function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
         after: Number(afterLink.lag)
       };
     }
+    const unchangedLink = beforeLink !== void 0 && Object.keys(fields).length === 0;
+    if (unchangedLink) continue;
     out.push({
       id: String(op.linkId),
       kind: ENTITY_CHANGE_KIND.UPDATED,
@@ -16126,6 +16407,69 @@ function hasInvalidPersistedProgress(action) {
   return progress !== void 0 && (action.activityIds.length !== 1 || !Number.isFinite(progress) || progress < 0 || progress > 100);
 }
 
+// src/dispatch/shared/lookahead-conversion-progress.ts
+function buildConversionProgressSnapshots(activities, criterion) {
+  const snapshots = new Map(
+    activities.map((activity) => [
+      activity.id,
+      structuredCloneActivity(activity)
+    ])
+  );
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const activity of activities) {
+    if (activity.parentId === null) continue;
+    const siblings = childrenByParent.get(activity.parentId) ?? [];
+    siblings.push(activity);
+    childrenByParent.set(activity.parentId, siblings);
+  }
+  const magnitudes = /* @__PURE__ */ new Map();
+  for (const activity of [...activities].reverse()) {
+    const children = childrenByParent.get(activity.id) ?? [];
+    const isSummary3 = children.length > 0;
+    const magnitude = isSummary3 ? children.reduce(
+      (sum2, child) => sum2 + requiredMagnitude(magnitudes, child.id),
+      0
+    ) : liveMagnitude(activity, criterion);
+    magnitudes.set(activity.id, magnitude);
+    if (!isSummary3) continue;
+    const hasMagnitude = magnitude > 0;
+    const permitsEqualShare = criterion !== ACTIVITY_PONDERATOR_CRITERION.COST;
+    for (const child of children) {
+      const snapshot2 = requiredSnapshot(snapshots, child.id);
+      const ponderator = hasMagnitude ? 100 * requiredMagnitude(magnitudes, child.id) / magnitude : permitsEqualShare ? 100 / children.length : 0;
+      snapshots.set(child.id, { ...snapshot2, ponderator });
+    }
+    const weightedChildren = children.map(
+      (child) => requiredSnapshot(snapshots, child.id)
+    );
+    const progress = computeWeightedProgressRollup(weightedChildren);
+    const snapshot = requiredSnapshot(snapshots, activity.id);
+    snapshots.set(activity.id, {
+      ...snapshot,
+      progress: roundProgressPerLevel(progress ?? 0)
+    });
+  }
+  return snapshots;
+}
+function liveMagnitude(activity, criterion) {
+  if (activity.type === ACTIVITY_TYPE.PROJECT) return 0;
+  if (criterion === ACTIVITY_PONDERATOR_CRITERION.COST) return activity.cost;
+  if (criterion === ACTIVITY_PONDERATOR_CRITERION.WORK_HOURS)
+    return activity.workHours;
+  return activity.durationHours;
+}
+function requiredMagnitude(magnitudes, activityId) {
+  const magnitude = magnitudes.get(activityId);
+  if (magnitude === void 0)
+    throw new Error(`Missing conversion magnitude ${activityId}`);
+  return magnitude;
+}
+function requiredSnapshot(snapshots, activityId) {
+  const snapshot = snapshots.get(activityId);
+  if (!snapshot) throw new Error(`Missing conversion snapshot ${activityId}`);
+  return snapshot;
+}
+
 // src/dispatch/handlers/activity-lookahead-convert.ts
 function buildLookaheadConversionPlan(input, deps) {
   const { adapter } = deps;
@@ -16140,7 +16484,11 @@ function buildLookaheadConversionPlan(input, deps) {
     (activityId) => requested.has(activityId) && !hasAncestorInSet(activityId, requested, adapter)
   );
   const branches = conversionRootIds.map(
-    (rootId) => planConversionBranch(rootId, adapter)
+    (rootId) => planConversionBranch(
+      rootId,
+      adapter,
+      input.criterion ?? deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
+    )
   );
   const conversionGroups = branches.map(
     ({ conversionRootId, convertedActivities }) => ({
@@ -16215,7 +16563,7 @@ async function dispatchActivityLookaheadConvert(action, options, deps) {
   });
   return buildConversionResult(plan, context, changes);
 }
-function planConversionBranch(rootId, adapter) {
+function planConversionBranch(rootId, adapter, criterion) {
   const root = requiredActivity(rootId, adapter);
   const branch = collectDescendantIds([rootId], adapter);
   branch.delete(rootId);
@@ -16232,15 +16580,19 @@ function planConversionBranch(rootId, adapter) {
     (activity) => activity.type === ACTIVITY_TYPE.MILESTONE
   );
   const persistedIds = collectPersistedIds(root, convertible);
+  const progressSnapshots = buildConversionProgressSnapshots(
+    [root, ...convertible],
+    criterion
+  );
+  const rootSnapshot = progressSnapshots.get(root.id);
+  if (!rootSnapshot) throw new Error(`Missing conversion snapshot ${root.id}`);
   return {
     conversionRootId: rootId,
-    convertedActivities: convertible.map(
-      (activity) => buildConvertedSnapshot(activity, persistedIds)
-    ),
+    convertedActivities: [...progressSnapshots.values()].filter((activity) => activity.id !== rootId).map((activity) => buildConvertedSnapshot(activity, persistedIds)),
     milestoneMoves: buildMilestoneMoves(root, milestones),
     activityIdsToDelete: convertible.map((activity) => activity.id),
     formerParent: {
-      activity: structuredCloneActivity(root),
+      activity: rootSnapshot,
       hasConvertedActivities: convertible.length > 0
     }
   };
@@ -16324,10 +16676,12 @@ function applyFormerParentState(plan, deletedIds, adapter) {
       idsRemoved: deletedIds
     });
     adapter.setActivityFields(activity.id, {
+      progress: activity.progress,
       isLookahead: activity.isLookahead || hasConvertedActivities,
       hasLookaheadTasks: activity.hasLookaheadTasks || hasConvertedActivities,
       ...cleanup?.fields ?? {}
     });
+    adapter.setProgressFallback(activity.id, null);
   }
 }
 function recomputeConversionRollups(plan, adapter) {
@@ -17406,8 +17760,9 @@ function isDateColumn(column) {
   return column === COLUMN.START_DATE || column === COLUMN.END_DATE;
 }
 async function dispatchDatesBatch(action, options, deps) {
-  if (action.edits.some((edit) => !isDateColumn(edit.column))) {
-    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  const rejection = validateBatchEdits(action, deps);
+  if (rejection !== null) {
+    return { ok: false, reason: rejection };
   }
   const { adapter, scheduler, sector } = deps;
   const verdicts = [];
@@ -17483,6 +17838,17 @@ async function dispatchDatesBatch(action, options, deps) {
     })
   };
 }
+function validateBatchEdits(action, deps) {
+  const hasInvalidColumn = action.edits.some(
+    (edit) => !isDateColumn(edit.column)
+  );
+  if (hasInvalidColumn) return REJECTION_REASON.INVALID_VALUE;
+  const hasMissingActivity = action.edits.some(
+    (edit) => deps.ctx.activityReader.getActivity(edit.activityId) === null
+  );
+  if (hasMissingActivity) return REJECTION_REASON.ACTIVITY_NOT_FOUND;
+  return null;
+}
 function applyOneEdit(edit, deps, options) {
   const { ctx } = deps;
   const activityId = edit.activityId;
@@ -18222,12 +18588,13 @@ function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarI
 
 // src/propagations/downward/recompute-all-ponderators.ts
 function recomputeAllPonderators(criterion, adapter) {
+  const basisById = /* @__PURE__ */ new Map();
   adapter.forEachActivity((_a, id) => {
     adapter.setActivityField(id, COLUMN.PONDERATOR, 0);
   });
   adapter.forEachActivity((_a, id) => {
     if (adapter.getChildren(id).length > 0) {
-      recomputePonderatorsForParent(String(id), criterion, adapter);
+      recomputePonderatorsForParent(String(id), criterion, adapter, basisById);
     }
   });
 }
@@ -18235,7 +18602,7 @@ function recomputeAllPonderators(criterion, adapter) {
 // src/dispatch/shared/baseline-weighted-fields.ts
 function recomputeBaselineWeightedFields(deps, criterion) {
   recomputeAllPonderators(criterion, deps.adapter);
-  recomputeAllProgressRollup(deps.adapter);
+  recomputeAllProgressRollup(deps.adapter, criterion);
   if (deps.now) {
     runExpectedProgressBase(
       deps.adapter,
@@ -18279,7 +18646,8 @@ async function dispatchBaselineApply(action, deps) {
     action.points,
     deps.now,
     deps.reporter,
-    deps.defaultBaseCalendarId ?? null
+    deps.defaultBaseCalendarId ?? null,
+    void 0
   );
   applyBaselineVariancePass(deps.adapter, deps.sector.hoursPerDay);
   if (activeBaselineSignature(deps) !== activeBaselineBefore) {
@@ -19010,7 +19378,10 @@ function dispatchCellCopy(action, deps) {
   if (!pipeline) {
     return { ok: false, reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN };
   }
-  const canonicalValue = readPipelineTargetValue(activity, pipeline.targetField);
+  const canonicalValue = readPipelineTargetValue(
+    activity,
+    pipeline.targetField
+  );
   if (action.column === COLUMN.DURATION && !Number.isFinite(canonicalValue)) {
     return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
   }
@@ -19336,6 +19707,7 @@ function coerceActivityFieldValue(field, value) {
 }
 
 // src/calendar/adapter.ts
+var WORK_CALENDAR_UNIT = { MINUTE: "minute" };
 function createWorkCalendarAdapter(instance, options = {}) {
   const defaultUnit = options.defaultUnit ?? CALENDAR_UNIT.HOUR;
   return {
@@ -19356,11 +19728,18 @@ function wrapWorkCalendar(calendar, defaultUnit) {
       });
     },
     calculateEndDate(start, durationHours) {
-      return calendar.calculateEndDate({
-        start_date: start,
+      const fractionalHours = defaultUnit === CALENDAR_UNIT.HOUR && !Number.isInteger(durationHours);
+      const sourceRemainder = start.getUTCSeconds() * 1e3 + start.getUTCMilliseconds();
+      const shouldPreserveSourcePrecision = fractionalHours && sourceRemainder !== 0 && calendar.isWorkTime({ date: start, unit: WORK_CALENDAR_UNIT.MINUTE });
+      const calculationStart = shouldPreserveSourcePrecision ? new Date(start.getTime() - sourceRemainder) : start;
+      const end = fractionalHours ? calculateFractionalEndDate(calendar, calculationStart, durationHours) : calendar.calculateEndDate({
+        start_date: calculationStart,
         duration: durationHours,
         unit: defaultUnit
       });
+      if (!shouldPreserveSourcePrecision) return end;
+      const workingEnd = nextWorkingMinute(calendar, end);
+      return new Date(workingEnd.getTime() + sourceRemainder);
     },
     calculateDuration(start, end) {
       return calendar.calculateDuration({
@@ -19377,6 +19756,91 @@ function wrapWorkCalendar(calendar, defaultUnit) {
     }
   };
 }
+function calculateFractionalEndDate(calendar, start, durationHours) {
+  const roundedMinutes = Math.round(Math.abs(durationHours) * 60);
+  const shouldUseWorkingPrefixes = roundedMinutes > 0 && calendar.isWorkTime({ date: start, unit: WORK_CALENDAR_UNIT.MINUTE });
+  if (!shouldUseWorkingPrefixes)
+    return calendar.calculateEndDate({
+      start_date: start,
+      duration: durationHours * 60,
+      unit: WORK_CALENDAR_UNIT.MINUTE
+    });
+  let end = start;
+  let remainingMinutes = roundedMinutes;
+  const direction = durationHours < 0 ? -1 : 1;
+  while (remainingMinutes > 0) {
+    const reference = direction < 0 ? new Date(end.getTime() - 1) : end;
+    if (!calendar.isWorkTime({ date: reference, unit: WORK_CALENDAR_UNIT.MINUTE })) {
+      end = direction < 0 ? calendar.getClosestWorkTime({
+        date: reference,
+        dir: WORK_TIME_DIRECTION.PAST,
+        unit: WORK_CALENDAR_UNIT.MINUTE
+      }) : nextWorkingMinute(calendar, end);
+    }
+    const prefix = calculateWorkingMinutePrefix(
+      calendar,
+      end,
+      Math.min(remainingMinutes, 60),
+      direction
+    );
+    end = prefix.end;
+    remainingMinutes -= prefix.minutes;
+  }
+  return end;
+}
+function calculateWorkingMinutePrefix(calendar, start, maximumMinutes, direction) {
+  const fullPrefix = calendar.calculateEndDate({
+    start_date: start,
+    duration: direction * maximumMinutes,
+    unit: WORK_CALENDAR_UNIT.MINUTE
+  });
+  const isFullPrefixContiguous = fullPrefix.getTime() === start.getTime() + direction * maximumMinutes * 6e4;
+  if (isFullPrefixContiguous)
+    return { end: fullPrefix, minutes: maximumMinutes };
+  let minutes = 0;
+  let limit = maximumMinutes - 1;
+  let end = start;
+  while (minutes < limit) {
+    const testedMinutes = Math.ceil((minutes + limit) / 2);
+    const candidate = calendar.calculateEndDate({
+      start_date: start,
+      duration: direction * testedMinutes,
+      unit: WORK_CALENDAR_UNIT.MINUTE
+    });
+    const isContiguousWorkingTime = candidate.getTime() === start.getTime() + direction * testedMinutes * 6e4;
+    if (isContiguousWorkingTime) {
+      minutes = testedMinutes;
+      end = candidate;
+    } else {
+      limit = testedMinutes - 1;
+    }
+  }
+  if (minutes === 0)
+    throw new Error("Calendar cannot calculate a working-minute prefix");
+  return { end, minutes };
+}
+function nextWorkingMinute(calendar, date2) {
+  if (calendar.isWorkTime({ date: date2, unit: WORK_CALENDAR_UNIT.MINUTE }))
+    return date2;
+  const nextWorkingDay2 = calendar.calculateEndDate({
+    start_date: date2,
+    duration: 1,
+    unit: CALENDAR_UNIT.DAY
+  });
+  const nextDayStart = new Date(nextWorkingDay2);
+  nextDayStart.setUTCHours(0, 0, 0, 0);
+  const nextShiftStart = calendar.getClosestWorkTime({
+    date: nextDayStart,
+    dir: WORK_TIME_DIRECTION.FUTURE,
+    unit: WORK_CALENDAR_UNIT.MINUTE
+  });
+  const closest = calendar.getClosestWorkTime({
+    date: date2,
+    dir: WORK_TIME_DIRECTION.FUTURE,
+    unit: WORK_CALENDAR_UNIT.MINUTE
+  });
+  return new Date(Math.min(closest.getTime(), nextShiftStart.getTime()));
+}
 function isArray(obj) {
   if (Array.isArray) {
     return Array.isArray(obj);
@@ -23478,13 +23942,263 @@ function computeProjectWorkHours(calendars) {
   return { startHour: earliestTime(starts), endHour: latestTime(ends) };
 }
 
-// src/internal/state/pipeline-context.ts
-function buildPipelineContext(adapter, options) {
-  return {
-    calendars: adapter.calendarReader,
-    hierarchy: createStateBackedHierarchyReader(adapter),
-    activityReader: createStateBackedActivityReader(adapter),
-    dateFormat: options.dateFormat ?? "YYYY-MM-DD",
+// src/boundary/backend/constants.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var EXCEPTION_DATE_FORMAT_REGEX = /^(\d{4})[/-](\d{1,2})[/-](\d{1,2})/;
+var WEEKDAYS_PER_WEEK = 7;
+var CALENDAR_FALLBACK_WORKING_DAYS = [false, true, true, true, true, true, false];
+var WORKING_DAY_TRUE_VALUES = /* @__PURE__ */ new Set([
+  "1",
+  "true"
+]);
+var DEFAULT_ACTIVITY_CRETER = ACTIVITY_PONDERATOR_CRITERION.DURATION;
+var DEFAULT_CONSTRAINT_TYPE = CONSTRAINT_TYPE.ASAP;
+var CONSTRAINT_LABEL_MAP = {
+  ASAP: CONSTRAINT_TYPE.ASAP,
+  ALAP: CONSTRAINT_TYPE.ALAP,
+  SNET: CONSTRAINT_TYPE.SNET,
+  SNLT: CONSTRAINT_TYPE.SNLT,
+  FNET: CONSTRAINT_TYPE.FNET,
+  FNLT: CONSTRAINT_TYPE.FNLT,
+  MSO: CONSTRAINT_TYPE.MSO,
+  MFO: CONSTRAINT_TYPE.MFO,
+  "AS SOON AS POSSIBLE": CONSTRAINT_TYPE.ASAP,
+  "AS LATE AS POSSIBLE": CONSTRAINT_TYPE.ALAP,
+  "START NO EARLIER THAN": CONSTRAINT_TYPE.SNET,
+  "START NO LATER THAN": CONSTRAINT_TYPE.SNLT,
+  "FINISH NO EARLIER THAN": CONSTRAINT_TYPE.FNET,
+  "FINISH NO LATER THAN": CONSTRAINT_TYPE.FNLT,
+  "MUST START ON": CONSTRAINT_TYPE.MSO,
+  "MUST FINISH ON": CONSTRAINT_TYPE.MFO
+};
+
+// src/boundary/backend/normalize-calendar.ts
+function normalizeCalendars(schedulingCalendars, sectorCalendars, rawBaseCalendars, exceptionRange = null) {
+  const hasSchedulingCalendars = schedulingCalendars !== void 0 && schedulingCalendars.length > 0;
+  const source = hasSchedulingCalendars ? schedulingCalendars : sectorCalendars ?? [];
+  const calendars = source.map(
+    (calendar) => parseSchedulingCalendar(calendar, exceptionRange)
+  );
+  const baseCalendars = (rawBaseCalendars ?? []).map(
+    (calendar) => parseBaseCalendar(calendar, exceptionRange)
+  );
+  return {
+    calendars,
+    baseCalendars,
+    knownCalendarIds: new Set(calendars.map((calendar) => calendar.id)),
+    defaultCalendarId: pickDefaultCalendarId(calendars)
+  };
+}
+function pickDefaultCalendarId(calendars) {
+  let firstCalendarId = null;
+  for (const calendar of calendars) {
+    firstCalendarId ??= calendar.id;
+    if (calendar.is_default) return calendar.id;
+  }
+  return firstCalendarId;
+}
+function buildCalendar(raw, shape) {
+  const workingMask = parseWorkingDays(raw.working_days);
+  const { days, hours } = parseWorktimeDays(raw, workingMask);
+  const dates = parseExceptionDays(
+    shape.exceptionsSource,
+    shape.exceptionRange
+  );
+  const worktime = { days, hours };
+  if (dates) worktime.dates = dates;
+  return {
+    id: `${String(raw.id)}${shape.idSuffix}`,
+    name: raw.name,
+    is_default: shape.isDefault,
+    ...shape.baseDefault !== void 0 ? { baseDefault: shape.baseDefault } : {},
+    worktime
+  };
+}
+function parseSchedulingCalendar(raw, exceptionRange) {
+  const rawBaseDefault = raw.baseDefault;
+  const baseDefault = typeof rawBaseDefault === "boolean" ? rawBaseDefault : void 0;
+  return buildCalendar(raw, {
+    idSuffix: "",
+    isDefault: Boolean(raw.is_default),
+    baseDefault,
+    exceptionsSource: raw.exceptiondays,
+    exceptionRange
+  });
+}
+function parseBaseCalendar(raw, exceptionRange) {
+  return buildCalendar(raw, {
+    idSuffix: "-base",
+    isDefault: false,
+    baseDefault: Boolean(raw.is_default),
+    exceptionsSource: raw.baseexceptiondays ?? raw.exceptiondays,
+    exceptionRange
+  });
+}
+function parseExceptionDays(exceptions, range) {
+  if (!Array.isArray(exceptions) || exceptions.length === 0) return null;
+  const map = {};
+  for (const exception of exceptions) {
+    if (!exception) continue;
+    const rangeKeys = expandRangeToUtcKeys(
+      exception.from_date,
+      exception.to_date,
+      range
+    );
+    if (rangeKeys.length === 0) continue;
+    const value = exceptionToDateValue(exception);
+    if (value === void 0) continue;
+    for (const key of rangeKeys) map[key] = value;
+  }
+  return Object.keys(map).length > 0 ? map : null;
+}
+function expandRangeToUtcKeys(from, to, range) {
+  const fromTs = parseExceptionDate(from);
+  const toTs = parseExceptionDate(to);
+  if (fromTs === null || toTs === null) return [];
+  if (range && (toTs < range.start || fromTs > range.end)) return [];
+  const keys = [];
+  let cursor = range ? Math.max(fromTs, range.start) : fromTs;
+  const last = range ? Math.min(toTs, range.end) : toTs;
+  while (cursor <= last) {
+    keys.push(String(cursor));
+    cursor += DAY_MS;
+  }
+  return keys;
+}
+function parseExceptionDate(raw) {
+  if (typeof raw !== "string") return null;
+  const match = EXCEPTION_DATE_FORMAT_REGEX.exec(raw.trim());
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const isValidDate4 = Number.isFinite(year) && Number.isFinite(month) && Number.isFinite(day);
+  if (!isValidDate4) return null;
+  return Date.UTC(year, month - 1, day);
+}
+function exceptionToDateValue(exception) {
+  if (exception.workable === false) return false;
+  const shifts = exception.shifts;
+  if (Array.isArray(shifts) && shifts.length > 0) {
+    const windows = extractExceptionWindows(shifts);
+    if (windows.length > 0) return windows;
+  }
+  return void 0;
+}
+var TIME_OF_DAY = /^\d{1,2}:\d{2}$/;
+function extractExceptionWindows(shifts) {
+  const windows = [];
+  for (const shift of shifts) {
+    const csvs = splitShiftString(shift?.shift_string);
+    if (!csvs) continue;
+    const isCompactWindow = !csvs.startsCsv.includes(",") && !csvs.endsCsv.includes(",");
+    if (isCompactWindow) {
+      const start = csvs.startsCsv.trim();
+      const end = csvs.endsCsv.trim();
+      const isUsableWindow = !isMissingValue(start) && !isMissingValue(end) && TIME_OF_DAY.test(start) && TIME_OF_DAY.test(end);
+      if (isUsableWindow) windows.push(`${start}-${end}`);
+      continue;
+    }
+    const perDay = shiftCsvToPerDayWindows(csvs.startsCsv, csvs.endsCsv);
+    const firstWindow = perDay.find((window2) => window2 !== null);
+    if (firstWindow) windows.push(firstWindow);
+  }
+  windows.sort(compareWindowByStart);
+  return windows;
+}
+function windowStartMinutes(window2) {
+  const dash = window2.indexOf("-");
+  const start = dash > 0 ? window2.slice(0, dash) : window2;
+  const [hour, minute] = start.split(":");
+  return (Number(hour) || 0) * 60 + (Number(minute) || 0);
+}
+function compareWindowByStart(first, second) {
+  return windowStartMinutes(first) - windowStartMinutes(second);
+}
+function parseWorktimeDays(raw, workingMask) {
+  const windowsByDay = Array.from({ length: 7 }, () => []);
+  const addCsvPair = (startsCsv, endsCsv) => {
+    const perDay = shiftCsvToPerDayWindows(startsCsv, endsCsv);
+    for (let i = 0; i < 7; i += 1) {
+      const window2 = perDay[i];
+      const dayWindows = windowsByDay[i];
+      if (window2 && dayWindows) dayWindows.push(window2);
+    }
+  };
+  const hasNestedShifts = Array.isArray(raw.shifts) && raw.shifts.length > 0;
+  const hasFlatShift = typeof raw.shift_start === "string" && typeof raw.shift_end === "string";
+  if (hasNestedShifts) {
+    for (const shift of raw.shifts) {
+      const csvs = splitShiftString(shift?.shift_string);
+      if (csvs) addCsvPair(csvs.startsCsv, csvs.endsCsv);
+    }
+  } else if (hasFlatShift) {
+    addCsvPair(raw.shift_start, raw.shift_end);
+  }
+  for (const dayWindows of windowsByDay) dayWindows.sort(compareWindowByStart);
+  const firstWorkingWindows = windowsByDay.find(
+    (windows, i) => Boolean(workingMask[i]) && windows.length > 0
+  );
+  const defaultHours = firstWorkingWindows ?? [];
+  const days = workingMask.map((isWorking, i) => {
+    if (!isWorking) return false;
+    const dayWindows = windowsByDay[i];
+    return dayWindows && dayWindows.length > 0 ? dayWindows : defaultHours;
+  });
+  return { days, hours: defaultHours };
+}
+function shiftCsvToPerDayWindows(startsCsv, endsCsv) {
+  const empty = Array.from(
+    { length: WEEKDAYS_PER_WEEK },
+    () => null
+  );
+  if (typeof startsCsv !== "string" || typeof endsCsv !== "string") {
+    return empty;
+  }
+  const starts = startsCsv.split(",").map((value) => value.trim());
+  const ends = endsCsv.split(",").map((value) => value.trim());
+  const isAlignedWeek = starts.length === ends.length && starts.length > 0 && starts.length <= WEEKDAYS_PER_WEEK;
+  if (!isAlignedWeek) return empty;
+  const windows = [...empty];
+  for (let i = 0; i < starts.length; i += 1) {
+    const start = starts[i];
+    const end = ends[i];
+    if (isMissingValue(start) || isMissingValue(end)) continue;
+    windows[i] = `${start}-${end}`;
+  }
+  return windows;
+}
+function splitShiftString(raw) {
+  if (typeof raw !== "string") return null;
+  const dash = raw.indexOf("-");
+  if (dash <= 0) return null;
+  return {
+    startsCsv: raw.slice(0, dash),
+    endsCsv: raw.slice(dash + 1)
+  };
+}
+function parseWorkingDays(csv) {
+  if (typeof csv !== "string") return [...CALENDAR_FALLBACK_WORKING_DAYS];
+  const parts = csv.split(",").map((value) => value.trim());
+  if (parts.length !== WEEKDAYS_PER_WEEK) {
+    return [...CALENDAR_FALLBACK_WORKING_DAYS];
+  }
+  return parts.map((part) => WORKING_DAY_TRUE_VALUES.has(part));
+}
+var MISSING_SHIFT_VALUES = /* @__PURE__ */ new Set(["false", "null"]);
+function isMissingValue(value) {
+  return !value || MISSING_SHIFT_VALUES.has(value);
+}
+
+// src/internal/state/pipeline-context.ts
+function buildPipelineContext(adapter, options) {
+  return {
+    calendars: adapter.calendarReader,
+    hasCalendar: (calendarId) => options.calendars.has(calendarId),
+    getDefaultCalendarId: () => pickDefaultCalendarId(options.calendars.values()),
+    hierarchy: createStateBackedHierarchyReader(adapter),
+    activityReader: createStateBackedActivityReader(adapter),
+    dateFormat: options.dateFormat ?? "YYYY-MM-DD",
     customHours: options.customHours ?? {},
     hoursPerDay: options.hoursPerDay
   };
@@ -24767,36 +25481,6 @@ var SaveTracker = class _SaveTracker {
   }
 };
 
-// src/boundary/backend/constants.ts
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var EXCEPTION_DATE_FORMAT_REGEX = /^(\d{4})[/-](\d{1,2})[/-](\d{1,2})/;
-var WEEKDAYS_PER_WEEK = 7;
-var CALENDAR_FALLBACK_WORKING_DAYS = [false, true, true, true, true, true, false];
-var WORKING_DAY_TRUE_VALUES = /* @__PURE__ */ new Set([
-  "1",
-  "true"
-]);
-var DEFAULT_ACTIVITY_CRETER = ACTIVITY_PONDERATOR_CRITERION.DURATION;
-var DEFAULT_CONSTRAINT_TYPE = CONSTRAINT_TYPE.ASAP;
-var CONSTRAINT_LABEL_MAP = {
-  ASAP: CONSTRAINT_TYPE.ASAP,
-  ALAP: CONSTRAINT_TYPE.ALAP,
-  SNET: CONSTRAINT_TYPE.SNET,
-  SNLT: CONSTRAINT_TYPE.SNLT,
-  FNET: CONSTRAINT_TYPE.FNET,
-  FNLT: CONSTRAINT_TYPE.FNLT,
-  MSO: CONSTRAINT_TYPE.MSO,
-  MFO: CONSTRAINT_TYPE.MFO,
-  "AS SOON AS POSSIBLE": CONSTRAINT_TYPE.ASAP,
-  "AS LATE AS POSSIBLE": CONSTRAINT_TYPE.ALAP,
-  "START NO EARLIER THAN": CONSTRAINT_TYPE.SNET,
-  "START NO LATER THAN": CONSTRAINT_TYPE.SNLT,
-  "FINISH NO EARLIER THAN": CONSTRAINT_TYPE.FNET,
-  "FINISH NO LATER THAN": CONSTRAINT_TYPE.FNLT,
-  "MUST START ON": CONSTRAINT_TYPE.MSO,
-  "MUST FINISH ON": CONSTRAINT_TYPE.MFO
-};
-
 // src/boundary/backend/normalize-activity.ts
 function normalizeActivities(rawActivities, context) {
   const hiddenIds = [];
@@ -24915,332 +25599,115 @@ function parseBaselinePoints(raw, reporter, recordDiagnostic, activityId, isMile
         record: recordDiagnostic,
         sampleId: activityId
       },
-      isMilestone
-    )
-  ).filter((point) => point !== null);
-}
-function parseActivity(raw, context) {
-  const calendarId = resolveCalendarId2(
-    raw.calendarId,
-    context.knownCalendarIds,
-    context.defaultCalendarId
-  );
-  const inheritedDefaultCalendar = raw.calendarId == null || !context.knownCalendarIds.has(String(raw.calendarId));
-  const progress = parseProgress(
-    raw.progress,
-    context.reporter,
-    context.recordDiagnostic,
-    String(raw.unique_id)
-  );
-  const { constraintType, constraintDate } = resolveConstraint(
-    raw,
-    context.reporter,
-    context.recordDiagnostic
-  );
-  const isMilestone = raw.type === ACTIVITY_TYPE.MILESTONE;
-  const startDate = parseBackendDate(raw.start_date);
-  const endDate = isMilestone ? startDate : parseBackendDate(raw.end_date);
-  const durationDays = isMilestone ? 0 : Number(raw.duration);
-  const isCritical = parseCriticality(raw, context.reporter);
-  return {
-    id: String(raw.unique_id),
-    proplannerId: normalizePersistedActivityId(raw.id),
-    parentId: parseParentId(raw.parent_id),
-    name: raw.name,
-    description: raw.description ?? "",
-    type: raw.type,
-    startDate,
-    endDate,
-    durationHours: durationToHours(durationDays, context.hoursPerDay),
-    constraintType,
-    constraintDate,
-    autoScheduling: isAutoSchedulingEnabledForProgress(progress),
-    calendarId,
-    assignedDefaultCalendar: calendarId != null && inheritedDefaultCalendar,
-    dateOrigin: raw.date_origin == null ? null : parseBackendDate(raw.date_origin),
-    progress,
-    cost: Number(raw.cost),
-    usedCost: Number(raw.used_cost ?? 0),
-    realCost: Number(raw.real_cost ?? 0),
-    workHours: Number(raw.hhWorkTime),
-    realWorkHours: Number(raw.real_work ?? 0),
-    ponderator: Number(raw.ponderator ?? 0),
-    hasCustomPonderator: raw.hasCustomPonderator,
-    correlativeId: raw.correlative_id,
-    uniqueCorrelativeId: raw.unique_correlative_id,
-    customId: normalizeCustomId(raw),
-    subcontractId: raw.subcontractId,
-    isLookahead: raw.isOnLookahead,
-    hasLookaheadTasks: Array.isArray(raw.tasks) && raw.tasks.length > 0,
-    newActivityIds: parseNewActivityIds(raw.newActivitiesArray),
-    hasNewActivities: raw.hasNewActivities ?? false,
-    ...raw.isNewActivity === true ? { isNewActivity: true } : {},
-    pendingRequestIds: parseIdList(raw.pendingRequests),
-    responsableIds: parseIdList(raw.responsables),
-    tagIds: parseIdList(raw.tags),
-    baselinePoints: parseBaselinePoints(
-      raw.baseline_points,
-      context.reporter,
-      context.recordDiagnostic,
-      String(raw.unique_id),
-      isMilestone
-    ),
-    baselineSnapshot: null,
-    baselineVarianceDays: null,
-    recursiveDurationHours: durationToHours(
-      Number(raw.sumOfDurationRecursively ?? 0),
-      context.hoursPerDay
-    ),
-    calendarDuration: computeCalendarDuration({
-      type: raw.type,
-      startDate,
-      endDate
-    }),
-    isCritical,
-    freeSlackHours: null,
-    expectedProgress: null,
-    expectedProgressBaseline: null,
-    status: null,
-    criticalPath: null
-  };
-}
-function normalizeCustomId(raw) {
-  return raw.has_childs ? null : raw.custom_id;
-}
-function forceRootProjectToRoot(activities) {
-  const rootProject = activities.find(
-    (activity) => activity.correlativeId === 0 && activity.type === ACTIVITY_TYPE.PROJECT
-  );
-  if (rootProject) rootProject.parentId = null;
-}
-function reparentOrphansToRoot(activities, ids, reporter, recordDiagnostic) {
-  for (const activity of activities) {
-    if (activity.parentId === null) continue;
-    if (!ids.has(activity.parentId)) {
-      reporter.warn(
-        `[parseFromBackend] activity "${activity.id}" references unknown parent "${activity.parentId}" \u2014 re-parenting to root (null)`
-      );
-      recordDiagnostic(LOAD_DIAGNOSTIC_CODE.ORPHAN_ACTIVITY, activity.id);
-      activity.parentId = null;
-    }
-  }
-}
-
-// src/boundary/backend/normalize-calendar.ts
-function normalizeCalendars(schedulingCalendars, sectorCalendars, rawBaseCalendars, exceptionRange = null) {
-  const hasSchedulingCalendars = schedulingCalendars !== void 0 && schedulingCalendars.length > 0;
-  const source = hasSchedulingCalendars ? schedulingCalendars : sectorCalendars ?? [];
-  const calendars = source.map(
-    (calendar) => parseSchedulingCalendar(calendar, exceptionRange)
-  );
-  const baseCalendars = (rawBaseCalendars ?? []).map(
-    (calendar) => parseBaseCalendar(calendar, exceptionRange)
-  );
-  return {
-    calendars,
-    baseCalendars,
-    knownCalendarIds: new Set(calendars.map((calendar) => calendar.id)),
-    defaultCalendarId: pickDefaultCalendarId(calendars)
-  };
-}
-function pickDefaultCalendarId(calendars) {
-  const flaggedDefault = calendars.find((calendar) => calendar.is_default);
-  if (flaggedDefault) return flaggedDefault.id;
-  const firstCalendar = calendars[0];
-  if (firstCalendar) return firstCalendar.id;
-  return null;
-}
-function buildCalendar(raw, shape) {
-  const workingMask = parseWorkingDays(raw.working_days);
-  const { days, hours } = parseWorktimeDays(raw, workingMask);
-  const dates = parseExceptionDays(
-    shape.exceptionsSource,
-    shape.exceptionRange
-  );
-  const worktime = { days, hours };
-  if (dates) worktime.dates = dates;
-  return {
-    id: `${String(raw.id)}${shape.idSuffix}`,
-    name: raw.name,
-    is_default: shape.isDefault,
-    ...shape.baseDefault !== void 0 ? { baseDefault: shape.baseDefault } : {},
-    worktime
-  };
-}
-function parseSchedulingCalendar(raw, exceptionRange) {
-  const rawBaseDefault = raw.baseDefault;
-  const baseDefault = typeof rawBaseDefault === "boolean" ? rawBaseDefault : void 0;
-  return buildCalendar(raw, {
-    idSuffix: "",
-    isDefault: Boolean(raw.is_default),
-    baseDefault,
-    exceptionsSource: raw.exceptiondays,
-    exceptionRange
-  });
-}
-function parseBaseCalendar(raw, exceptionRange) {
-  return buildCalendar(raw, {
-    idSuffix: "-base",
-    isDefault: false,
-    baseDefault: Boolean(raw.is_default),
-    exceptionsSource: raw.baseexceptiondays ?? raw.exceptiondays,
-    exceptionRange
-  });
-}
-function parseExceptionDays(exceptions, range) {
-  if (!Array.isArray(exceptions) || exceptions.length === 0) return null;
-  const map = {};
-  for (const exception of exceptions) {
-    if (!exception) continue;
-    const rangeKeys = expandRangeToUtcKeys(
-      exception.from_date,
-      exception.to_date,
-      range
-    );
-    if (rangeKeys.length === 0) continue;
-    const value = exceptionToDateValue(exception);
-    if (value === void 0) continue;
-    for (const key of rangeKeys) map[key] = value;
-  }
-  return Object.keys(map).length > 0 ? map : null;
-}
-function expandRangeToUtcKeys(from, to, range) {
-  const fromTs = parseExceptionDate(from);
-  const toTs = parseExceptionDate(to);
-  if (fromTs === null || toTs === null) return [];
-  if (range && (toTs < range.start || fromTs > range.end)) return [];
-  const keys = [];
-  let cursor = range ? Math.max(fromTs, range.start) : fromTs;
-  const last = range ? Math.min(toTs, range.end) : toTs;
-  while (cursor <= last) {
-    keys.push(String(cursor));
-    cursor += DAY_MS;
-  }
-  return keys;
-}
-function parseExceptionDate(raw) {
-  if (typeof raw !== "string") return null;
-  const match = EXCEPTION_DATE_FORMAT_REGEX.exec(raw.trim());
-  if (!match) return null;
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  const isValidDate4 = Number.isFinite(year) && Number.isFinite(month) && Number.isFinite(day);
-  if (!isValidDate4) return null;
-  return Date.UTC(year, month - 1, day);
-}
-function exceptionToDateValue(exception) {
-  if (exception.workable === false) return false;
-  const shifts = exception.shifts;
-  if (Array.isArray(shifts) && shifts.length > 0) {
-    const windows = extractExceptionWindows(shifts);
-    if (windows.length > 0) return windows;
-  }
-  return void 0;
-}
-var TIME_OF_DAY = /^\d{1,2}:\d{2}$/;
-function extractExceptionWindows(shifts) {
-  const windows = [];
-  for (const shift of shifts) {
-    const csvs = splitShiftString(shift?.shift_string);
-    if (!csvs) continue;
-    const isCompactWindow = !csvs.startsCsv.includes(",") && !csvs.endsCsv.includes(",");
-    if (isCompactWindow) {
-      const start = csvs.startsCsv.trim();
-      const end = csvs.endsCsv.trim();
-      const isUsableWindow = !isMissingValue(start) && !isMissingValue(end) && TIME_OF_DAY.test(start) && TIME_OF_DAY.test(end);
-      if (isUsableWindow) windows.push(`${start}-${end}`);
-      continue;
-    }
-    const perDay = shiftCsvToPerDayWindows(csvs.startsCsv, csvs.endsCsv);
-    const firstWindow = perDay.find((window2) => window2 !== null);
-    if (firstWindow) windows.push(firstWindow);
-  }
-  windows.sort(compareWindowByStart);
-  return windows;
-}
-function windowStartMinutes(window2) {
-  const dash = window2.indexOf("-");
-  const start = dash > 0 ? window2.slice(0, dash) : window2;
-  const [hour, minute] = start.split(":");
-  return (Number(hour) || 0) * 60 + (Number(minute) || 0);
-}
-function compareWindowByStart(first, second) {
-  return windowStartMinutes(first) - windowStartMinutes(second);
-}
-function parseWorktimeDays(raw, workingMask) {
-  const windowsByDay = Array.from({ length: 7 }, () => []);
-  const addCsvPair = (startsCsv, endsCsv) => {
-    const perDay = shiftCsvToPerDayWindows(startsCsv, endsCsv);
-    for (let i = 0; i < 7; i += 1) {
-      const window2 = perDay[i];
-      const dayWindows = windowsByDay[i];
-      if (window2 && dayWindows) dayWindows.push(window2);
-    }
-  };
-  const hasNestedShifts = Array.isArray(raw.shifts) && raw.shifts.length > 0;
-  const hasFlatShift = typeof raw.shift_start === "string" && typeof raw.shift_end === "string";
-  if (hasNestedShifts) {
-    for (const shift of raw.shifts) {
-      const csvs = splitShiftString(shift?.shift_string);
-      if (csvs) addCsvPair(csvs.startsCsv, csvs.endsCsv);
-    }
-  } else if (hasFlatShift) {
-    addCsvPair(raw.shift_start, raw.shift_end);
-  }
-  for (const dayWindows of windowsByDay) dayWindows.sort(compareWindowByStart);
-  const firstWorkingWindows = windowsByDay.find(
-    (windows, i) => Boolean(workingMask[i]) && windows.length > 0
-  );
-  const defaultHours = firstWorkingWindows ?? [];
-  const days = workingMask.map((isWorking, i) => {
-    if (!isWorking) return false;
-    const dayWindows = windowsByDay[i];
-    return dayWindows && dayWindows.length > 0 ? dayWindows : defaultHours;
-  });
-  return { days, hours: defaultHours };
-}
-function shiftCsvToPerDayWindows(startsCsv, endsCsv) {
-  const empty = Array.from(
-    { length: WEEKDAYS_PER_WEEK },
-    () => null
-  );
-  if (typeof startsCsv !== "string" || typeof endsCsv !== "string") {
-    return empty;
-  }
-  const starts = startsCsv.split(",").map((value) => value.trim());
-  const ends = endsCsv.split(",").map((value) => value.trim());
-  const isAlignedWeek = starts.length === ends.length && starts.length > 0 && starts.length <= WEEKDAYS_PER_WEEK;
-  if (!isAlignedWeek) return empty;
-  const windows = [...empty];
-  for (let i = 0; i < starts.length; i += 1) {
-    const start = starts[i];
-    const end = ends[i];
-    if (isMissingValue(start) || isMissingValue(end)) continue;
-    windows[i] = `${start}-${end}`;
-  }
-  return windows;
+      isMilestone
+    )
+  ).filter((point) => point !== null);
 }
-function splitShiftString(raw) {
-  if (typeof raw !== "string") return null;
-  const dash = raw.indexOf("-");
-  if (dash <= 0) return null;
+function parseActivity(raw, context) {
+  const calendarId = resolveCalendarId2(
+    raw.calendarId,
+    context.knownCalendarIds,
+    context.defaultCalendarId
+  );
+  const inheritedDefaultCalendar = raw.calendarId == null || !context.knownCalendarIds.has(String(raw.calendarId));
+  const progress = parseProgress(
+    raw.progress,
+    context.reporter,
+    context.recordDiagnostic,
+    String(raw.unique_id)
+  );
+  const { constraintType, constraintDate } = resolveConstraint(
+    raw,
+    context.reporter,
+    context.recordDiagnostic
+  );
+  const isMilestone = raw.type === ACTIVITY_TYPE.MILESTONE;
+  const startDate = parseBackendDate(raw.start_date);
+  const endDate = isMilestone ? startDate : parseBackendDate(raw.end_date);
+  const durationDays = isMilestone ? 0 : Number(raw.duration);
+  const isCritical = parseCriticality(raw, context.reporter);
   return {
-    startsCsv: raw.slice(0, dash),
-    endsCsv: raw.slice(dash + 1)
+    id: String(raw.unique_id),
+    proplannerId: normalizePersistedActivityId(raw.id),
+    parentId: parseParentId(raw.parent_id),
+    name: raw.name,
+    description: raw.description ?? "",
+    type: raw.type,
+    startDate,
+    endDate,
+    durationHours: durationToHours(durationDays, context.hoursPerDay),
+    constraintType,
+    constraintDate,
+    autoScheduling: isAutoSchedulingEnabledForProgress(progress),
+    calendarId,
+    assignedDefaultCalendar: calendarId != null && inheritedDefaultCalendar,
+    dateOrigin: raw.date_origin == null ? null : parseBackendDate(raw.date_origin),
+    progress,
+    cost: Number(raw.cost),
+    usedCost: Number(raw.used_cost ?? 0),
+    realCost: Number(raw.real_cost ?? 0),
+    workHours: Number(raw.hhWorkTime),
+    realWorkHours: Number(raw.real_work ?? 0),
+    ponderator: Number(raw.ponderator ?? 0),
+    hasCustomPonderator: raw.hasCustomPonderator,
+    correlativeId: raw.correlative_id,
+    uniqueCorrelativeId: raw.unique_correlative_id,
+    customId: normalizeCustomId(raw),
+    subcontractId: raw.subcontractId,
+    isLookahead: raw.isOnLookahead,
+    hasLookaheadTasks: Array.isArray(raw.tasks) && raw.tasks.length > 0,
+    newActivityIds: parseNewActivityIds(raw.newActivitiesArray),
+    hasNewActivities: raw.hasNewActivities ?? false,
+    ...raw.isNewActivity === true ? { isNewActivity: true } : {},
+    pendingRequestIds: parseIdList(raw.pendingRequests),
+    responsableIds: parseIdList(raw.responsables),
+    tagIds: parseIdList(raw.tags),
+    baselinePoints: parseBaselinePoints(
+      raw.baseline_points,
+      context.reporter,
+      context.recordDiagnostic,
+      String(raw.unique_id),
+      isMilestone
+    ),
+    baselineSnapshot: null,
+    baselineVarianceDays: null,
+    recursiveDurationHours: durationToHours(
+      Number(raw.sumOfDurationRecursively ?? 0),
+      context.hoursPerDay
+    ),
+    calendarDuration: computeCalendarDuration({
+      type: raw.type,
+      startDate,
+      endDate
+    }),
+    isCritical,
+    freeSlackHours: null,
+    expectedProgress: null,
+    expectedProgressBaseline: null,
+    status: null,
+    criticalPath: null
   };
 }
-function parseWorkingDays(csv) {
-  if (typeof csv !== "string") return [...CALENDAR_FALLBACK_WORKING_DAYS];
-  const parts = csv.split(",").map((value) => value.trim());
-  if (parts.length !== WEEKDAYS_PER_WEEK) {
-    return [...CALENDAR_FALLBACK_WORKING_DAYS];
-  }
-  return parts.map((part) => WORKING_DAY_TRUE_VALUES.has(part));
+function normalizeCustomId(raw) {
+  return raw.has_childs ? null : raw.custom_id;
 }
-var MISSING_SHIFT_VALUES = /* @__PURE__ */ new Set(["false", "null"]);
-function isMissingValue(value) {
-  return !value || MISSING_SHIFT_VALUES.has(value);
+function forceRootProjectToRoot(activities) {
+  const rootProject = activities.find(
+    (activity) => activity.correlativeId === 0 && activity.type === ACTIVITY_TYPE.PROJECT
+  );
+  if (rootProject) rootProject.parentId = null;
+}
+function reparentOrphansToRoot(activities, ids, reporter, recordDiagnostic) {
+  for (const activity of activities) {
+    if (activity.parentId === null) continue;
+    if (!ids.has(activity.parentId)) {
+      reporter.warn(
+        `[parseFromBackend] activity "${activity.id}" references unknown parent "${activity.parentId}" \u2014 re-parenting to root (null)`
+      );
+      recordDiagnostic(LOAD_DIAGNOSTIC_CODE.ORPHAN_ACTIVITY, activity.id);
+      activity.parentId = null;
+    }
+  }
 }
 
 // src/boundary/backend/normalize-link.ts
@@ -26175,23 +26642,40 @@ function recomputeCanonicalRealWork(state) {
   state.forEachActivity((activity, activityId) => {
     if (activity.parentId === null) rootIds.push(String(activityId));
   });
-  const visit = (activityId) => {
-    const activity = state.getActivity(activityId);
-    if (!activity) return 0;
-    const childIds = [...state.getChildren(activityId)];
-    const realWork = childIds.length === 0 ? computeLeafRealWork(activity.workHours, activity.progress) : childIds.reduce(
-      (total, childId) => total + visit(String(childId)),
-      0
-    );
+  const stack = rootIds.map((activityId) => ({
+    activityId,
+    parent: null,
+    childIds: null,
+    realWork: 0
+  })).reverse();
+  for (let frame = stack.pop(); frame; frame = stack.pop()) {
+    if (frame.childIds === null) {
+      const activity = state.getActivity(frame.activityId);
+      if (!activity) continue;
+      const childIds = [...state.getChildren(frame.activityId)];
+      const isLeaf = childIds.length === 0;
+      frame.childIds = childIds.values();
+      frame.realWork = isLeaf ? computeLeafRealWork(activity.workHours, activity.progress) : 0;
+    }
+    const nextChild = frame.childIds.next();
+    const hasNextChild = !nextChild.done;
+    if (hasNextChild) {
+      stack.push(frame, {
+        activityId: String(nextChild.value),
+        parent: frame,
+        childIds: null,
+        realWork: 0
+      });
+      continue;
+    }
     state.setActivityField(
-      activityId,
+      frame.activityId,
       ACTIVITY_PROPERTY.REAL_WORK_HOURS,
-      realWork
+      frame.realWork
     );
-    changedIds.push(activityId);
-    return realWork;
-  };
-  for (const rootId of rootIds) visit(rootId);
+    changedIds.push(frame.activityId);
+    if (frame.parent) frame.parent.realWork += frame.realWork;
+  }
   return changedIds;
 }
 
@@ -26204,8 +26688,16 @@ async function runInitialPasses(deps) {
   }
   normalizeLoadedConstraintDates(state);
   recomputeCanonicalRealWork(state);
+  if (sector.activityCreter === ACTIVITY_PONDERATOR_CRITERION.COST) {
+    let hasActiveBaseline2 = false;
+    state.forEachActivity((activity) => {
+      hasActiveBaseline2 ||= getActiveBaseline(activity) !== null;
+    });
+    if (hasActiveBaseline2)
+      recomputeAllPonderators(ACTIVITY_PONDERATOR_CRITERION.COST, state);
+  }
   if (skipAutoSchedule) {
-    recomputeAllProgressRollup(state);
+    recomputeAllProgressRollup(state, sector.activityCreter);
     if (now) {
       applyExpectedProgressLive(state, now);
       applyStatusPass(state, sector.statusCriteria);
@@ -26218,7 +26710,7 @@ async function runInitialPasses(deps) {
   normalizeMilestoneConstraintDatesForDisplay(state);
   recomputeSkippedLeafEnds(state);
   await updateParentBoundsFromChildren(state, void 0, false);
-  recomputeAllProgressRollup(state);
+  recomputeAllProgressRollup(state, sector.activityCreter);
   if (now) {
     applyExpectedProgressLive(state, now);
     applyStatusPass(state, sector.statusCriteria);
@@ -26691,6 +27183,39 @@ function clampPercent(value) {
   return Math.min(MAXIMUM_PERCENT, Math.max(MINIMUM_PERCENT, value));
 }
 
+// src/p6/rolled-expected-finish.ts
+var PINNABLE_ACTIVITY_TYPES = /* @__PURE__ */ new Set([
+  P6_ACTIVITY_TYPE.TASK,
+  P6_ACTIVITY_TYPE.RESOURCE_DEPENDENT
+]);
+var NO_ROLLED_EXPECTED_FINISHES = /* @__PURE__ */ new Map();
+function planRolledExpectedFinishes(input) {
+  const adoptsShownFinishes = input.settings.useExpectedFinishDates && rollsDataDateForward(input.previousSettings, input.settings);
+  if (!adoptsShownFinishes) return NO_ROLLED_EXPECTED_FINISHES;
+  const pinned = /* @__PURE__ */ new Map();
+  for (const [activityId, state] of input.activities) {
+    const shownFinish = state.remainingEarlyFinish;
+    if (shownFinish === null) continue;
+    if (!needsExpectedFinishPin(state)) continue;
+    pinned.set(activityId, new Date(shownFinish));
+  }
+  return pinned;
+}
+function rollsDataDateForward(previous, next) {
+  const previousDataDate = previous.dataDate;
+  const nextDataDate = next.dataDate;
+  if (previousDataDate === null || nextDataDate === null) return false;
+  return nextDataDate.getTime() > previousDataDate.getTime();
+}
+function needsExpectedFinishPin(state) {
+  return state.executionStatus === P6_EXECUTION_STATUS.IN_PROGRESS && state.expectedFinish === null && hasPinnableActivityType(state);
+}
+function hasPinnableActivityType(state) {
+  const { activityType } = state;
+  if (activityType === void 0) return true;
+  return PINNABLE_ACTIVITY_TYPES.has(activityType);
+}
+
 // src/p6/scheduler-projection.ts
 function buildDataDateAuthorityFields(p6, settings) {
   return {
@@ -26733,20 +27258,32 @@ function buildDataDateScheduleProjection(input) {
 }
 
 // src/p6/live-derived.ts
-function prepareDataDateLiveDerived(source, before, after) {
+function prepareDataDateLiveDerived(source, before, after, options = {}) {
   if (!dataDateChanged(before.dataDate, after.dataDate)) return /* @__PURE__ */ new Map();
   if (!hasActiveDataDate(after)) return /* @__PURE__ */ new Map();
   const activating = !hasActiveDataDate(before);
+  const activities = source.getAllActivities();
+  const rolledExpectedFinishes = planSettingsExpectedFinishes(
+    activities,
+    before,
+    after,
+    options.adoptExpectedFinish
+  );
   const patches = /* @__PURE__ */ new Map();
-  for (const activity of source.getAllActivities()) {
+  for (const activity of activities) {
     const p6 = activity.p6;
     if (p6 === void 0) continue;
     const calendar = source.calendarReader.getCalendar(activity.calendarId);
     if (calendar === null) {
       throw new Error(`Missing calendar for Data Date activity ${activity.id}`);
     }
-    const nextP6 = liveDerivedState(p6, after.dataDate, calendar);
-    const p6Changed = !Object.is(nextP6.schedulePercentComplete, p6.schedulePercentComplete) || !Object.is(nextP6.actualDurationHours, p6.actualDurationHours);
+    const nextP6 = liveDerivedState(
+      p6,
+      after.dataDate,
+      calendar,
+      rolledExpectedFinishes.get(activity.id)
+    );
+    const p6Changed = !Object.is(nextP6.expectedFinish, p6.expectedFinish) || !Object.is(nextP6.schedulePercentComplete, p6.schedulePercentComplete) || !Object.is(nextP6.actualDurationHours, p6.actualDurationHours);
     if (!activating && !p6Changed) continue;
     patches.set(activity.id, {
       ...p6Changed ? { p6: nextP6 } : {},
@@ -26755,17 +27292,37 @@ function prepareDataDateLiveDerived(source, before, after) {
   }
   return patches;
 }
+function planSettingsExpectedFinishes(activities, before, after, adoptExpectedFinish = false) {
+  if (!adoptExpectedFinish) return /* @__PURE__ */ new Map();
+  const overridesDataDateWithForecast = after.setDataDateAndPlannedStartToForecastStart && after.projectForecastStart !== null;
+  if (overridesDataDateWithForecast) return /* @__PURE__ */ new Map();
+  const scheduledActivities = new Map(
+    activities.flatMap((activity) => {
+      const p6 = activity.p6;
+      const hasSchedulingState = p6 !== void 0 && isP6ActivityState(p6);
+      if (activity.type === ACTIVITY_TYPE.PROJECT || !hasSchedulingState)
+        return [];
+      return [[activity.id, p6]];
+    })
+  );
+  return planRolledExpectedFinishes({
+    previousSettings: before,
+    settings: after,
+    activities: scheduledActivities
+  });
+}
 function applyDataDateLiveDerived(writer, patches) {
   for (const [activityId, fields] of patches) {
     writer.setActivityFields(activityId, fields);
   }
 }
-function liveDerivedState(p6, dataDate, calendar) {
+function liveDerivedState(p6, dataDate, calendar, rolledExpectedFinish) {
   const context = { dataDate, calendar };
   const schedulePercentComplete = deriveP6SchedulePercentComplete(p6, context);
   const measuresActualDuration = isP6ActivityState(p6) && p6.executionStatus === P6_EXECUTION_STATUS.IN_PROGRESS;
   return {
     ...p6,
+    expectedFinish: rolledExpectedFinish ?? p6.expectedFinish,
     schedulePercentComplete,
     ...measuresActualDuration ? { actualDurationHours: deriveP6ActualDurationHours(p6, context) } : {}
   };
@@ -29207,8 +29764,8 @@ function compareActivityReference(leftId, rightId, adapter, settings) {
 function collectFreeFloatPaths(endingActivityId2, adapter, forward, settings) {
   const paths = [];
   const assigned = /* @__PURE__ */ new Set();
-  const visit = (pathEndId) => {
-    if (assigned.has(pathEndId)) return;
+  const pending = [endingActivityId2];
+  for (let pathEndId = pending.pop(); pathEndId !== void 0; pathEndId = pending.pop()) {
     const path = [];
     let currentId = pathEndId;
     while (currentId !== null && !assigned.has(currentId)) {
@@ -29218,23 +29775,24 @@ function collectFreeFloatPaths(endingActivityId2, adapter, forward, settings) {
       path.push(currentId);
       currentId = startsFreeFloatPathSegment(currentId, adapter, settings) ? null : resolvePrimaryPathPredecessor(currentId, adapter, forward, settings);
     }
-    if (path.length === 0) return;
+    if (path.length === 0) continue;
     paths.push(path);
-    for (const activityId of path) {
+    const alternatives = [...path].reverse().flatMap((activityId) => {
       const primaryPredecessor = startsFreeFloatPathSegment(
         activityId,
         adapter,
         settings
       ) ? null : resolvePrimaryPathPredecessor(activityId, adapter, forward, settings);
-      const alternatives = adapter.getIncomingLinkIds(activityId).map((linkId) => adapter.getLink(linkId)).filter(
+      return adapter.getIncomingLinkIds(activityId).map((linkId) => adapter.getLink(linkId)).filter(
         (link) => link !== null && link.source !== primaryPredecessor
       ).sort(
-        (left, right) => left.source.localeCompare(right.source) || left.id.localeCompare(right.id)
+        (left, right) => right.source.localeCompare(left.source) || right.id.localeCompare(left.id)
       );
-      for (const link of alternatives) visit(link.source);
+    });
+    for (const link of alternatives) {
+      pending.push(link.source);
     }
-  };
-  visit(endingActivityId2);
+  }
   return paths;
 }
 function startsFreeFloatPathSegment(activityId, adapter, settings) {
@@ -29378,6 +29936,103 @@ function resolvePrimaryPathPredecessor(activityId, adapter, forward, settings) {
   return resolveLongestPathPredecessors(activityId, adapter, forward, settings)[0] ?? null;
 }
 
+// src/p6/settings-enums.ts
+function validateP6ScheduleSettingEnums(settings) {
+  validateChoice(settings.outOfSequencePolicy, "outOfSequencePolicy", [
+    "retained_logic",
+    "progress_override",
+    "actual_dates"
+  ]);
+  validateChoice(settings.dependencyReference, "dependencyReference", [
+    "correlative_id",
+    "custom_id"
+  ]);
+  validateChoice(settings.startToStartLagBasis, "startToStartLagBasis", [
+    "actual_start",
+    "early_start"
+  ]);
+  validateChoice(settings.relationshipLagCalendar, "relationshipLagCalendar", [
+    "predecessor",
+    "successor",
+    "project_default",
+    "twenty_four_hour"
+  ]);
+  validateChoice(settings.totalFloatMethod, "totalFloatMethod", [
+    "start_float",
+    "finish_float",
+    "smallest"
+  ]);
+  validateChoice(
+    settings.criticalActivityMethod,
+    "criticalActivityMethod",
+    Object.values(P6_CRITICAL_ACTIVITY_METHOD)
+  );
+  validateChoice(settings.calculateFloatBasedOn, "calculateFloatBasedOn", [
+    "each_project",
+    "opened_projects"
+  ]);
+}
+function validateChoice(value, field, allowed) {
+  if (allowed.includes(value)) return;
+  throw new Error(`Invalid P6 schedule settings: ${field}`);
+}
+
+// src/p6/wbs-summary-activities.ts
+function prependAncestor(ancestorId, matches, requested) {
+  return requested.has(ancestorId) ? { ancestorId, next: matches } : matches;
+}
+function cacheCycleMatches(path, cycleStart, requested, cache) {
+  const cycle = path.slice(cycleStart).reverse();
+  let matches = null;
+  for (const ancestorId of cycle)
+    matches = prependAncestor(ancestorId, matches, requested);
+  for (const ancestorId of cycle) cache.set(ancestorId, matches);
+  return matches;
+}
+function resolveAncestorMatches(parentId, byId, requested, cache) {
+  const path = [];
+  const positions = /* @__PURE__ */ new Map();
+  let currentId = parentId;
+  while (currentId !== null && !cache.has(currentId) && !positions.has(currentId)) {
+    positions.set(currentId, path.length);
+    path.push(currentId);
+    currentId = byId.get(currentId)?.parentId ?? null;
+  }
+  let matches = currentId === null ? null : cache.get(currentId) ?? null;
+  const cycleStart = currentId === null ? void 0 : positions.get(currentId);
+  let lastIndex = path.length - 1;
+  if (cycleStart !== void 0) {
+    matches = cacheCycleMatches(path, cycleStart, requested, cache);
+    lastIndex = cycleStart - 1;
+  }
+  for (let index = lastIndex; index >= 0; index -= 1) {
+    const ancestorId = path[index];
+    if (ancestorId === void 0) throw new Error("Missing WBS ancestor");
+    matches = prependAncestor(ancestorId, matches, requested);
+    cache.set(ancestorId, matches);
+  }
+  return cache.get(parentId) ?? null;
+}
+function groupWbsSummaryActivities(activities, byId, ancestorIds) {
+  const groups = /* @__PURE__ */ new Map();
+  if (ancestorIds.size === 0) return groups;
+  const cache = /* @__PURE__ */ new Map();
+  for (const activity of activities) {
+    const isRealActivity = activity.p6 !== void 0 && activity.p6.activityType !== P6_ACTIVITY_TYPE.WBS_SUMMARY;
+    if (!isRealActivity) continue;
+    const parentId = activity.parentId;
+    if (parentId === null) continue;
+    let matches = resolveAncestorMatches(parentId, byId, ancestorIds, cache);
+    while (matches !== null) {
+      const bucket = groups.get(matches.ancestorId);
+      if (bucket === void 0) groups.set(matches.ancestorId, [activity]);
+      else bucket.push(activity);
+      matches = matches.next;
+    }
+  }
+  return groups;
+}
+
 // src/p6/schedule.ts
 var EMPTY_LEVEL_OF_EFFORT_WINDOWS = {
   remainingEarlyStart: null,
@@ -29529,27 +30184,6 @@ function calculateP6Schedule(input) {
   ];
   return { activities, criticalPath, warnings };
 }
-function groupActivitiesByWbsAncestor(all, byId) {
-  const childrenByAncestor = /* @__PURE__ */ new Map();
-  for (const activity of all) {
-    if (activity.p6 === void 0 || activity.p6.activityType === "wbs_summary") {
-      continue;
-    }
-    let currentId = activity.parentId;
-    const visited = /* @__PURE__ */ new Set();
-    while (currentId !== null && !visited.has(currentId)) {
-      visited.add(currentId);
-      const bucket = childrenByAncestor.get(currentId);
-      if (bucket === void 0) {
-        childrenByAncestor.set(currentId, [activity]);
-      } else {
-        bucket.push(activity);
-      }
-      currentId = byId.get(currentId)?.parentId ?? null;
-    }
-  }
-  return childrenByAncestor;
-}
 function hasNoPrimaryConstraint(constraintType) {
   return (constraintType ?? CONSTRAINT_TYPE.ASAP) === CONSTRAINT_TYPE.ASAP;
 }
@@ -29860,11 +30494,20 @@ function settleIsolatedLevelOfEffort(current, scheduled, dataDate) {
 function calculateWbsSummaries(input) {
   const { adapter, settings, activities } = input;
   const all = adapter.getAllActivities();
+  const summaries = sortedP6Activities(
+    all.filter(
+      (activity) => activity.p6?.activityType === P6_ACTIVITY_TYPE.WBS_SUMMARY
+    )
+  );
+  const ancestorIds = new Set(
+    summaries.flatMap(
+      (summary) => summary.parentId === null ? [] : [summary.parentId]
+    )
+  );
+  if (ancestorIds.size === 0) return;
   const byId = new Map(all.map((activity) => [activity.id, activity]));
-  const childrenByAncestor = groupActivitiesByWbsAncestor(all, byId);
-  for (const summary of sortedP6Activities(all).filter(
-    (activity) => activity.p6?.activityType === "wbs_summary"
-  )) {
+  const childrenByAncestor = groupWbsSummaryActivities(all, byId, ancestorIds);
+  for (const summary of summaries) {
     if (summary.parentId === null) continue;
     const children = childrenByAncestor.get(summary.parentId) ?? [];
     if (children.length === 0) continue;
@@ -29987,6 +30630,7 @@ function validateP6ScheduleSettings(settings) {
   if (endingActivityId2 !== null && typeof endingActivityId2 !== "string" && (typeof endingActivityId2 !== "number" || !Number.isFinite(endingActivityId2))) {
     throw new Error("Invalid P6 schedule settings: ending activity ID");
   }
+  validateP6ScheduleSettingEnums(settings);
 }
 function sortedP6Activities(activities) {
   return activities.filter((activity) => activity.p6 !== void 0).sort((left, right) => String(left.id).localeCompare(String(right.id)));
@@ -30160,39 +30804,6 @@ function blockedActivities(code, message, activityIds, missingInputs = []) {
   };
 }
 
-// src/p6/rolled-expected-finish.ts
-var PINNABLE_ACTIVITY_TYPES = /* @__PURE__ */ new Set([
-  P6_ACTIVITY_TYPE.TASK,
-  P6_ACTIVITY_TYPE.RESOURCE_DEPENDENT
-]);
-var NO_ROLLED_EXPECTED_FINISHES = /* @__PURE__ */ new Map();
-function planRolledExpectedFinishes(input) {
-  const adoptsShownFinishes = input.settings.useExpectedFinishDates && rollsDataDateForward(input.previousSettings, input.settings);
-  if (!adoptsShownFinishes) return NO_ROLLED_EXPECTED_FINISHES;
-  const pinned = /* @__PURE__ */ new Map();
-  for (const [activityId, state] of input.activities) {
-    const shownFinish = state.remainingEarlyFinish;
-    if (shownFinish === null) continue;
-    if (!needsExpectedFinishPin(state)) continue;
-    pinned.set(activityId, new Date(shownFinish));
-  }
-  return pinned;
-}
-function rollsDataDateForward(previous, next) {
-  const previousDataDate = previous.dataDate;
-  const nextDataDate = next.dataDate;
-  if (previousDataDate === null || nextDataDate === null) return false;
-  return nextDataDate.getTime() > previousDataDate.getTime();
-}
-function needsExpectedFinishPin(state) {
-  return state.executionStatus === P6_EXECUTION_STATUS.IN_PROGRESS && state.expectedFinish === null && hasPinnableActivityType(state);
-}
-function hasPinnableActivityType(state) {
-  const { activityType } = state;
-  if (activityType === void 0) return true;
-  return PINNABLE_ACTIVITY_TYPES.has(activityType);
-}
-
 // src/p6/commands.ts
 function dataDateScheduleReadiness(input) {
   const preflight = getP6SchedulePreflight({
@@ -30410,6 +31021,10 @@ function throwPreflight(preflight) {
 }
 function validateActivityInputPatch(patch) {
   validateDates2(patch);
+  const executionStatus = patch.executionStatus;
+  if ("executionStatus" in patch && executionStatus !== P6_EXECUTION_STATUS.NOT_STARTED && executionStatus !== P6_EXECUTION_STATUS.IN_PROGRESS && executionStatus !== P6_EXECUTION_STATUS.COMPLETED) {
+    throw new Error("Invalid P6 activity input: execution status");
+  }
   for (const value of [
     patch.remainingDurationHours,
     patch.originalDurationHours,
@@ -31069,9 +31684,7 @@ var ScheduleCore = class _ScheduleCore {
       this._activityClipboard.value = cloneDomainValue(
         source._activityClipboard.value
       );
-      this._cellClipboard.value = cloneDomainValue(
-        source._cellClipboard.value
-      );
+      this._cellClipboard.value = cloneDomainValue(source._cellClipboard.value);
       this._undo = source._undo.fork();
       this._saveTracker = source._saveTracker.fork();
       this._scheduleRevision = source._scheduleRevision;
@@ -31242,6 +31855,7 @@ var ScheduleCore = class _ScheduleCore {
     const activity = readActivity(this.coreRuntime.state, id);
     if (!activity) return null;
     const context = buildPipelineContext(this.coreRuntime.state, {
+      calendars: this.coreRuntime.calendars,
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
       dateFormat: this.coreRuntime.sector.dateFormat
     });
@@ -31276,6 +31890,7 @@ var ScheduleCore = class _ScheduleCore {
     const pipeline = findPipelineForColumn(column);
     if (!activity || !pipeline) return null;
     const context = buildPipelineContext(this.coreRuntime.state, {
+      calendars: this.coreRuntime.calendars,
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
       dateFormat: this.coreRuntime.sector.dateFormat
     });
@@ -31836,7 +32451,8 @@ var ScheduleCore = class _ScheduleCore {
         const liveDerived = capability.prepareLiveDerived(
           this.coreRuntime.state,
           before,
-          after
+          after,
+          { adoptExpectedFinish: true }
         );
         const touchedIds = [...liveDerived.keys()];
         const beforeSnap = new Map(
@@ -32265,6 +32881,7 @@ var ScheduleCore = class _ScheduleCore {
     this.assertReady();
     return buildLookaheadConversionPlan(input, {
       adapter: this.coreRuntime.state,
+      sector: this.getSector(),
       stateRevision: this._stateRevision
     });
   }
@@ -32312,6 +32929,16 @@ var ScheduleCore = class _ScheduleCore {
             });
             continue;
           }
+          const manualSchedulingActive = hasActiveDataDate(
+            this.coreRuntime.state.dataDateSettings()
+          );
+          if (manualSchedulingActive) {
+            results.push({
+              ok: false,
+              reason: REJECTION_REASON.MANUAL_SCHEDULING_ACTIVE
+            });
+            continue;
+          }
           const changes = emptyChangeSet2(action);
           results.push({ ok: true, changes });
           acceptedChangeSets.push(changes);
@@ -32413,6 +33040,7 @@ var ScheduleCore = class _ScheduleCore {
       };
     }
     const pipelineContext = buildPipelineContext(this.coreRuntime.state, {
+      calendars: this.coreRuntime.calendars,
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
       dateFormat: this.coreRuntime.sector.dateFormat
     });