@outbuild-company/schedule-core 1.35.1 → 1.35.3

package/dist/index.cjs

@@ -13002,11 +13002,6 @@ function rejectedGesture(editability) {
     ...editability.alertKey ? { alertKey: editability.alertKey } : {}
   };
 }
-var STATUS_ONLY_CHANGES = {
-  patch: {},
-  needsAutoSchedule: false,
-  postProcessors: []
-};
 function resolveDataDateProgressButton(activity, progress, progressChanges, deps, confirmations) {
   const governsProgress = deps.dataDateCapability !== null && hasActiveDataDate(deps.dataDateSettings, deps.dataDateEnabled);
   if (!governsProgress) return null;
@@ -13020,19 +13015,19 @@ function resolveDataDateProgressButton(activity, progress, progressChanges, deps
   if (activity.p6 === void 0) return null;
   return resolveDataDateFieldChanges(
     activity,
-    progressChanges ?? STATUS_ONLY_CHANGES,
+    progressChanges,
     deps,
     COLUMN.PROGRESS,
     confirmations,
     {
       progress,
       explicitCompletion: true,
-      writesProgress: progressChanges !== null
+      writesProgress: activity.p6.percentCompleteType !== P6_PERCENT_COMPLETE_TYPE.UNITS
     }
   );
 }
 function resolveDataDateFieldChanges(activity, changes, deps, column, confirmations, progressRouting, editedStart = null) {
-  const generic = routeGenericColumnEdit(
+  const routed = routeGenericColumnEdit(
     activity,
     routeConstraintTypeEdit(activity, changes, column),
     deps,
@@ -13041,9 +13036,8 @@ function resolveDataDateFieldChanges(activity, changes, deps, column, confirmati
     progressRouting,
     editedStart
   );
-  if (generic === null) return rejected(REJECTION_REASON.INVALID_VALUE);
-  if ("accepted" in generic) return generic;
-  const routed = limitTransitionActuals(activity, generic, deps, column);
+  if (routed === null) return rejected(REJECTION_REASON.INVALID_VALUE);
+  if ("accepted" in routed) return routed;
   if (routed.dataDatePatch === void 0) return accepted(routed);
   if (activity.p6 === void 0 || deps.dataDateCapability === null) {
     return rejected(REJECTION_REASON.INVALID_VALUE);
@@ -13103,32 +13097,6 @@ function withMirroredProgress(activity, changes, next, deps, column) {
   }
   return { ...changes, patch: { ...changes.patch, progress: percent } };
 }
-var EXECUTION_TRANSITION_COLUMNS = /* @__PURE__ */ new Set([
-  COLUMN.PROGRESS,
-  COLUMN.EXECUTION_STATUS,
-  COLUMN.PHYSICAL_PERCENT_COMPLETE
-]);
-function limitTransitionActuals(activity, changes, deps, column) {
-  const dataDate = deps.dataDateSettings?.dataDate ?? null;
-  if (!EXECUTION_TRANSITION_COLUMNS.has(column) || dataDate === null || changes.dataDatePatch === void 0 || !hasActiveDataDate(deps.dataDateSettings, deps.dataDateEnabled)) {
-    return changes;
-  }
-  const calendar = deps.ctx.calendars.getCalendar(activity.calendarId);
-  const limit = calendar === null ? { start: dataDate, finish: dataDate } : completionActualsLimit(dataDate, calendar);
-  const recordedStart = activity.p6?.actualStart ?? null;
-  const floor = recordedStart !== null && recordedStart <= dataDate ? recordedStart : null;
-  const alternative = changes.confirmationAlternative;
-  return {
-    ...changes,
-    dataDatePatch: capActualDates(changes.dataDatePatch, floor, limit),
-    ...alternative === void 0 ? {} : {
-      confirmationAlternative: {
-        ...alternative,
-        effects: capActualDates(alternative.effects, floor, limit)
-      }
-    }
-  };
-}
 function accepted(changes) {
   return { accepted: true, changes };
 }
@@ -16117,6 +16085,315 @@ async function dispatchHistoryRevert(action, options, deps) {
   };
 }
 
+// src/p6/status.ts
+var INVALID_STATUS = "Invalid P6 activity status";
+var P6ActivityStatusError = class extends Error {
+  constructor(code, reason) {
+    super(`${INVALID_STATUS}: ${reason}`);
+    this.code = code;
+    this.name = "P6ActivityStatusError";
+  }
+  code;
+};
+var COMPLETED_PHYSICAL_PERCENT2 = 100;
+var NOT_STARTED_PHYSICAL_PERCENT2 = 0;
+function validateP6ActivityStatus(activity) {
+  validateRemainingDuration(activity.remainingDurationHours);
+  validateDates(activity);
+  validateExecutionStatus(activity);
+  validateDateOrder(activity);
+}
+function validateP6ActivityDraftStatus(activity) {
+  validateDraftRemainingDuration(activity.remainingDurationHours);
+  validateDates(activity);
+  validateDraftExecutionStatus(activity);
+  validateDateOrder(activity);
+}
+function normalizeP6ActualDatePatch(current, patch) {
+  if (patch.actualStart === void 0 && patch.actualFinish === void 0) {
+    return patch;
+  }
+  const actualStart = patch.actualStart !== void 0 ? patch.actualStart : current.actualStart;
+  const actualFinish = patch.actualFinish !== void 0 ? patch.actualFinish : current.actualFinish;
+  const executionStatus = actualFinish !== null ? "completed" : actualStart !== null ? "in_progress" : "not_started";
+  const unStarting = actualStart === null && actualFinish === null && current.actualStart !== null;
+  const normalized2 = {
+    ...patch,
+    executionStatus,
+    ...actualFinish !== null ? {
+      remainingDurationHours: 0,
+      physicalPercentComplete: COMPLETED_PHYSICAL_PERCENT2
+    } : {},
+    ...unStarting ? {
+      remainingDurationHours: current.originalDurationHours,
+      physicalPercentComplete: NOT_STARTED_PHYSICAL_PERCENT2
+    } : {}
+  };
+  validateP6ActivityDraftStatus({ ...current, ...normalized2 });
+  return normalized2;
+}
+function validateRemainingDuration(remainingDurationHours) {
+  if (!Number.isFinite(remainingDurationHours) || remainingDurationHours < 0) {
+    invalid2("Remaining Duration must be finite and non-negative");
+  }
+}
+function validateDraftRemainingDuration(remainingDurationHours) {
+  if (remainingDurationHours === null) return;
+  validateRemainingDuration(remainingDurationHours);
+}
+function validateDates(activity) {
+  const dates = [
+    activity.actualStart,
+    activity.actualFinish,
+    activity.suspendDate,
+    activity.resumeDate
+  ];
+  if (dates.some((date2) => date2 !== null && Number.isNaN(date2.getTime()))) {
+    invalid2("actual, suspend and resume dates must be valid");
+  }
+}
+function validateExecutionStatus(activity) {
+  const hasActualStart = activity.actualStart !== null;
+  const hasActualFinish = activity.actualFinish !== null;
+  if (activity.executionStatus === "not_started") {
+    if (hasActualStart || hasActualFinish) {
+      invalid2("not_started cannot have actual dates");
+    }
+    return;
+  }
+  if (activity.executionStatus === "in_progress") {
+    if (!hasActualStart || hasActualFinish) {
+      invalid2("in_progress requires Actual Start and no Actual Finish");
+    }
+    return;
+  }
+  if (!hasActualStart || !hasActualFinish || activity.remainingDurationHours !== 0) {
+    invalid2(
+      "completed requires Actual Start, Actual Finish and zero Remaining Duration"
+    );
+  }
+}
+function validateDraftExecutionStatus(activity) {
+  const hasActualStart = activity.actualStart !== null;
+  const hasActualFinish = activity.actualFinish !== null;
+  if (hasActualFinish && !hasActualStart) {
+    invalid2("Actual Finish requires Actual Start");
+  }
+  if (activity.executionStatus === "not_started" && hasActualStart) {
+    invalid2("not_started cannot have actual dates");
+  }
+  if (activity.executionStatus === "in_progress" && hasActualFinish) {
+    invalid2("in_progress cannot have Actual Finish");
+  }
+  if (activity.executionStatus === "completed" && activity.remainingDurationHours !== null && activity.remainingDurationHours !== 0) {
+    invalid2("completed requires zero Remaining Duration");
+  }
+}
+function validateDateOrder(activity) {
+  const { actualStart, actualFinish, suspendDate, resumeDate } = activity;
+  if (actualStart !== null && actualFinish !== null && actualStart.getTime() > actualFinish.getTime()) {
+    throw new P6ActivityStatusError(
+      "ACTUAL_FINISH_BEFORE_START",
+      "Actual Start must not be after Actual Finish"
+    );
+  }
+  if (suspendDate !== null) {
+    if (actualStart === null) invalid2("Suspend requires Actual Start");
+    if (actualStart.getTime() > suspendDate.getTime()) {
+      invalid2("Suspend must not be before Actual Start");
+    }
+    if (actualFinish !== null && suspendDate.getTime() > actualFinish.getTime()) {
+      invalid2("Suspend must not be after Actual Finish");
+    }
+  }
+  if (resumeDate === null) return;
+  if (suspendDate === null) invalid2("Resume requires Suspend");
+  if (suspendDate.getTime() > resumeDate.getTime()) {
+    invalid2("Suspend must not be after Resume");
+  }
+  if (actualFinish !== null && resumeDate.getTime() > actualFinish.getTime()) {
+    invalid2("Resume must not be after Actual Finish");
+  }
+}
+function invalid2(reason) {
+  throw new Error(`${INVALID_STATUS}: ${reason}`);
+}
+
+// src/p6/lookahead-progress-transition.ts
+var LookaheadActualTransitionError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "LookaheadActualTransitionError";
+  }
+  code;
+};
+var ACTUAL_DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+function resolveLookaheadActualDateSelection(input) {
+  if (!validDate(input.timeSource)) invalid3("INVALID_ACTUAL_TIME_SOURCE");
+  const parts = actualDayParts(input.selectedDay);
+  const [year, month, day] = parts;
+  const result = new Date(input.timeSource);
+  result.setUTCFullYear(year, month - 1, day);
+  if (!sameUtcDay2(result, parts)) invalid3("INVALID_ACTUAL_DAY");
+  return result;
+}
+function actualDayParts(value) {
+  const match = ACTUAL_DAY_PATTERN.exec(value);
+  if (!match) invalid3("INVALID_ACTUAL_DAY");
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function planLookaheadProgressActuals(input) {
+  validateInput(input);
+  if (input.dataDate === null) {
+    return { start: null, finish: null, uncomplete: null };
+  }
+  const start = input.activity.executionStatus === P6_EXECUTION_STATUS.NOT_STARTED && input.nextProgress > NOT_STARTED_PROGRESS ? { required: true, suggestedAt: new Date(input.dataDate) } : null;
+  const finish = input.activity.executionStatus !== P6_EXECUTION_STATUS.COMPLETED && input.nextProgress === COMPLETED_PROGRESS ? {
+    optional: true,
+    suggestedAt: input.displayedFinish ? new Date(input.displayedFinish) : null
+  } : null;
+  const uncomplete = input.activity.executionStatus === P6_EXECUTION_STATUS.COMPLETED && input.activity.actualFinish !== null && input.nextProgress < COMPLETED_PROGRESS ? {
+    required: true,
+    removes: new Date(input.activity.actualFinish)
+  } : null;
+  return { start, finish, uncomplete };
+}
+function prepareLookaheadProgressActuals(input) {
+  const plan = planLookaheadProgressActuals(input);
+  if (input.dataDate === null && hasIntent(input.intent)) {
+    invalid3("DATA_DATE_INACTIVE");
+  }
+  if (plan.start && input.intent?.actualStart === void 0) {
+    invalid3("ACTUAL_START_REQUIRED");
+  }
+  if (input.intent?.actualFinish instanceof Date && input.nextProgress !== COMPLETED_PROGRESS) {
+    invalid3("ACTUAL_FINISH_REQUIRES_100");
+  }
+  if (plan.uncomplete && input.intent?.actualFinish !== null) {
+    invalid3("ACTUAL_FINISH_REMOVAL_REQUIRED");
+  }
+  if (!plan.uncomplete && input.intent?.actualFinish === null) {
+    invalid3("ACTUAL_FINISH_REMOVAL_NOT_APPLICABLE");
+  }
+  const actuals = normalizeP6ActualDatePatch(
+    input.activity,
+    input.intent ?? {}
+  );
+  if (input.dataDate === null) return actuals;
+  return withMirroredPercent(input.activity, actuals, input.nextProgress);
+}
+function prepareLookaheadProgressActualsForPersistence(input) {
+  const { resolveCalendar, ...progressInput } = input;
+  const preparedActuals = prepareLookaheadProgressActuals(progressInput);
+  if (input.dataDate === null) {
+    return preparedActuals;
+  }
+  const actualStart = input.intent?.actualStart;
+  const needsActualStartNormalization = actualStart !== void 0 && isUtcMidnight(actualStart);
+  if (!needsActualStartNormalization) return preparedActuals;
+  const intent = normalizeActualStart(
+    input.intent,
+    input.activity.actualStart,
+    resolveCalendar
+  );
+  if (intent === void 0) {
+    return preparedActuals;
+  }
+  return prepareLookaheadProgressActuals({ ...progressInput, intent });
+}
+function normalizeActualStart(intent, existingActualStart, resolveCalendar) {
+  if (intent?.actualStart === void 0) return intent;
+  if (!isUtcMidnight(intent.actualStart)) return intent;
+  if (existingActualStart !== null) {
+    return {
+      ...intent,
+      actualStart: resolveLookaheadActualDateSelection({
+        selectedDay: intent.actualStart.toISOString().slice(0, 10),
+        timeSource: existingActualStart
+      })
+    };
+  }
+  const calendar = resolveCalendar();
+  if (calendar === null) {
+    invalid3("ACTIVITY_CALENDAR_REQUIRED");
+  }
+  return {
+    ...intent,
+    actualStart: defaultActualStartTime(intent.actualStart, calendar)
+  };
+}
+function withMirroredPercent(activity, actuals, nextProgress) {
+  const executionStatus = actuals.executionStatus ?? activity.executionStatus;
+  if (executionStatus !== P6_EXECUTION_STATUS.IN_PROGRESS) return actuals;
+  switch (activity.percentCompleteType) {
+    case P6_PERCENT_COMPLETE_TYPE.PHYSICAL:
+      return { ...actuals, physicalPercentComplete: nextProgress };
+    case P6_PERCENT_COMPLETE_TYPE.DURATION:
+      return {
+        ...actuals,
+        remainingDurationHours: activity.originalDurationHours * (1 - nextProgress / COMPLETED_PROGRESS)
+      };
+    default:
+      return actuals;
+  }
+}
+function validateInput(input) {
+  if (!Number.isFinite(input.nextProgress) || input.nextProgress < NOT_STARTED_PROGRESS || input.nextProgress > COMPLETED_PROGRESS) {
+    invalid3("INVALID_PROGRESS");
+  }
+  if (input.dataDate !== null && !validDate(input.dataDate)) {
+    invalid3("INVALID_DATA_DATE");
+  }
+  if (input.displayedFinish != null && !validDate(input.displayedFinish)) {
+    invalid3("INVALID_DISPLAYED_FINISH");
+  }
+}
+function validDate(value) {
+  return value instanceof Date && Number.isFinite(value.getTime());
+}
+function sameUtcDay2(value, [year, month, day]) {
+  return value.getUTCFullYear() === year && value.getUTCMonth() === month - 1 && value.getUTCDate() === day;
+}
+function hasIntent(intent) {
+  return intent?.actualStart !== void 0 || intent?.actualFinish !== void 0;
+}
+function invalid3(code) {
+  throw new LookaheadActualTransitionError(code);
+}
+
+// src/p6/lookahead-reconciliation.ts
+function preparePersistedLookaheadDataDate(action, activity, deps) {
+  const settings = deps.dataDateSettings;
+  const capability = deps.dataDateCapability;
+  if (action.persistedProgress === void 0 || activity?.p6 === void 0 || capability === null || !hasActiveDataDate(settings, deps.dataDateEnabled) || settings?.dataDate == null)
+    return null;
+  const patch = prepareLookaheadProgressActuals({
+    dataDate: settings.dataDate,
+    activity: activity.p6,
+    nextProgress: action.persistedProgress,
+    ...action.persistedActualTransition === void 0 ? {} : { intent: action.persistedActualTransition }
+  });
+  const prepared = capability.prepareActivityUpdate(
+    activity.p6,
+    {
+      originalDurationHours: activity.p6.originalDurationHours,
+      ...patch.actualStart === void 0 ? {} : { actualStart: patch.actualStart },
+      ...patch.actualFinish === void 0 ? {} : { actualFinish: patch.actualFinish },
+      ...patch.remainingDurationHours == null ? {} : { remainingDurationHours: patch.remainingDurationHours },
+      ...patch.physicalPercentComplete == null ? {} : { physicalPercentComplete: patch.physicalPercentComplete }
+    },
+    activity.constraintType
+  );
+  const calendar = deps.adapter.calendarReader.getCalendar(activity.calendarId);
+  const projection = calendar === null ? { p6: prepared.next, startDate: void 0, endDate: void 0 } : capability.projectLocalActivity(activity.p6, prepared.next, {
+    calendar,
+    dataDate: settings.dataDate,
+    totalFloatMethod: settings.totalFloatMethod
+  });
+  return { activityId: activity.id, ...projection };
+}
+
 // src/dispatch/handlers/persistence-acknowledge.ts
 var EMPTY_OWNERS = /* @__PURE__ */ new Map();
 function persistedOwnersOf(entities) {
@@ -16335,6 +16612,30 @@ async function dispatchActivityLookaheadSync(action, options, deps) {
   if (snapshots.some((snapshot) => !snapshot)) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
   }
+  const persistedDataDate = preparePersistedLookaheadDataDate(
+    action,
+    snapshots[0],
+    deps
+  );
+  if (persistedDataDate !== null) {
+    deps.adapter.setActivityField(
+      persistedDataDate.activityId,
+      "p6",
+      persistedDataDate.p6
+    );
+    if (persistedDataDate.startDate !== void 0)
+      deps.adapter.setActivityField(
+        persistedDataDate.activityId,
+        "startDate",
+        persistedDataDate.startDate
+      );
+    if (persistedDataDate.endDate !== void 0)
+      deps.adapter.setActivityField(
+        persistedDataDate.activityId,
+        "endDate",
+        persistedDataDate.endDate
+      );
+  }
   const activities = [];
   for (const [index, id] of ids.entries()) {
     const snapshot = snapshots[index];
@@ -16375,7 +16676,7 @@ async function dispatchActivityLookaheadSync(action, options, deps) {
       [{ activityId: ids[0], progress: action.persistedProgress }],
       deps
     );
-    if (progressChanges.length > 0) {
+    if (progressChanges.length > 0 || persistedDataDate !== null) {
       await runPostMutation(
         {
           adapter: deps.adapter,
@@ -17617,7 +17918,7 @@ async function dispatchActivitySetProgress(action, options, deps) {
   const statusRouting = resolveDataDateProgressButton(
     activitySnap,
     action.newValue,
-    editGate.allowed ? progressChanges : null,
+    progressChanges,
     deps,
     options.confirmations
   );
@@ -17625,17 +17926,14 @@ async function dispatchActivitySetProgress(action, options, deps) {
     return rejectedRouting(statusRouting);
   }
   const changes = statusRouting === null ? progressChanges : statusRouting.changes;
-  const writesProgress = statusRouting === null || editGate.allowed;
   const touchedIds = collectTouchedIds(action.activityId, changes);
-  const beforeSnap = await snapshotActivities(adapter, touchedIds);
-  applyFieldChanges(adapter, action.activityId, changes);
-  if (writesProgress) {
-    setExplicitSummaryProgressFallbacks(
-      action.activityId,
-      action.newValue,
-      adapter
-    );
-  }
+  const beforeSnap = await snapshotActivities(adapter, touchedIds);
+  applyFieldChanges(adapter, action.activityId, changes);
+  setExplicitSummaryProgressFallbacks(
+    action.activityId,
+    action.newValue,
+    adapter
+  );
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
@@ -26797,140 +27095,6 @@ function changed(before, after) {
   return serializeCanonicalSchedule(before) !== serializeCanonicalSchedule(after);
 }
 
-// src/p6/status.ts
-var INVALID_STATUS = "Invalid P6 activity status";
-var P6ActivityStatusError = class extends Error {
-  constructor(code, reason) {
-    super(`${INVALID_STATUS}: ${reason}`);
-    this.code = code;
-    this.name = "P6ActivityStatusError";
-  }
-  code;
-};
-var COMPLETED_PHYSICAL_PERCENT2 = 100;
-var NOT_STARTED_PHYSICAL_PERCENT2 = 0;
-function validateP6ActivityStatus(activity) {
-  validateRemainingDuration(activity.remainingDurationHours);
-  validateDates(activity);
-  validateExecutionStatus(activity);
-  validateDateOrder(activity);
-}
-function validateP6ActivityDraftStatus(activity) {
-  validateDraftRemainingDuration(activity.remainingDurationHours);
-  validateDates(activity);
-  validateDraftExecutionStatus(activity);
-  validateDateOrder(activity);
-}
-function normalizeP6ActualDatePatch(current, patch) {
-  if (patch.actualStart === void 0 && patch.actualFinish === void 0) {
-    return patch;
-  }
-  const actualStart = patch.actualStart !== void 0 ? patch.actualStart : current.actualStart;
-  const actualFinish = patch.actualFinish !== void 0 ? patch.actualFinish : current.actualFinish;
-  const executionStatus = actualFinish !== null ? "completed" : actualStart !== null ? "in_progress" : "not_started";
-  const unStarting = actualStart === null && actualFinish === null && current.actualStart !== null;
-  const normalized2 = {
-    ...patch,
-    executionStatus,
-    ...actualFinish !== null ? {
-      remainingDurationHours: 0,
-      physicalPercentComplete: COMPLETED_PHYSICAL_PERCENT2
-    } : {},
-    ...unStarting ? {
-      remainingDurationHours: current.originalDurationHours,
-      physicalPercentComplete: NOT_STARTED_PHYSICAL_PERCENT2
-    } : {}
-  };
-  validateP6ActivityDraftStatus({ ...current, ...normalized2 });
-  return normalized2;
-}
-function validateRemainingDuration(remainingDurationHours) {
-  if (!Number.isFinite(remainingDurationHours) || remainingDurationHours < 0) {
-    invalid2("Remaining Duration must be finite and non-negative");
-  }
-}
-function validateDraftRemainingDuration(remainingDurationHours) {
-  if (remainingDurationHours === null) return;
-  validateRemainingDuration(remainingDurationHours);
-}
-function validateDates(activity) {
-  const dates = [
-    activity.actualStart,
-    activity.actualFinish,
-    activity.suspendDate,
-    activity.resumeDate
-  ];
-  if (dates.some((date2) => date2 !== null && Number.isNaN(date2.getTime()))) {
-    invalid2("actual, suspend and resume dates must be valid");
-  }
-}
-function validateExecutionStatus(activity) {
-  const hasActualStart = activity.actualStart !== null;
-  const hasActualFinish = activity.actualFinish !== null;
-  if (activity.executionStatus === "not_started") {
-    if (hasActualStart || hasActualFinish) {
-      invalid2("not_started cannot have actual dates");
-    }
-    return;
-  }
-  if (activity.executionStatus === "in_progress") {
-    if (!hasActualStart || hasActualFinish) {
-      invalid2("in_progress requires Actual Start and no Actual Finish");
-    }
-    return;
-  }
-  if (!hasActualStart || !hasActualFinish || activity.remainingDurationHours !== 0) {
-    invalid2(
-      "completed requires Actual Start, Actual Finish and zero Remaining Duration"
-    );
-  }
-}
-function validateDraftExecutionStatus(activity) {
-  const hasActualStart = activity.actualStart !== null;
-  const hasActualFinish = activity.actualFinish !== null;
-  if (hasActualFinish && !hasActualStart) {
-    invalid2("Actual Finish requires Actual Start");
-  }
-  if (activity.executionStatus === "not_started" && hasActualStart) {
-    invalid2("not_started cannot have actual dates");
-  }
-  if (activity.executionStatus === "in_progress" && hasActualFinish) {
-    invalid2("in_progress cannot have Actual Finish");
-  }
-  if (activity.executionStatus === "completed" && activity.remainingDurationHours !== null && activity.remainingDurationHours !== 0) {
-    invalid2("completed requires zero Remaining Duration");
-  }
-}
-function validateDateOrder(activity) {
-  const { actualStart, actualFinish, suspendDate, resumeDate } = activity;
-  if (actualStart !== null && actualFinish !== null && actualStart.getTime() > actualFinish.getTime()) {
-    throw new P6ActivityStatusError(
-      "ACTUAL_FINISH_BEFORE_START",
-      "Actual Start must not be after Actual Finish"
-    );
-  }
-  if (suspendDate !== null) {
-    if (actualStart === null) invalid2("Suspend requires Actual Start");
-    if (actualStart.getTime() > suspendDate.getTime()) {
-      invalid2("Suspend must not be before Actual Start");
-    }
-    if (actualFinish !== null && suspendDate.getTime() > actualFinish.getTime()) {
-      invalid2("Suspend must not be after Actual Finish");
-    }
-  }
-  if (resumeDate === null) return;
-  if (suspendDate === null) invalid2("Resume requires Suspend");
-  if (suspendDate.getTime() > resumeDate.getTime()) {
-    invalid2("Suspend must not be after Resume");
-  }
-  if (actualFinish !== null && resumeDate.getTime() > actualFinish.getTime()) {
-    invalid2("Resume must not be after Actual Finish");
-  }
-}
-function invalid2(reason) {
-  throw new Error(`${INVALID_STATUS}: ${reason}`);
-}
-
 // src/p6/derived.ts
 var INVALID_INPUT = "Invalid P6 derived input";
 var PERCENT_SCALE2 = 100;
@@ -30899,48 +31063,48 @@ function optionalP6Date(rawValue) {
 function yesNo(rawValue) {
   if (rawValue === "Y") return true;
   if (rawValue === "N") return false;
-  invalid3(`expected Y/N, got "${rawValue}"`);
+  invalid4(`expected Y/N, got "${rawValue}"`);
 }
 function enumValue(map, rawValue) {
-  if (!Object.hasOwn(map, rawValue)) invalid3(`unknown enum "${rawValue}"`);
+  if (!Object.hasOwn(map, rawValue)) invalid4(`unknown enum "${rawValue}"`);
   return map[rawValue];
 }
 function outOfSequencePolicy(schedule) {
   const retained = yesNo(schedule.sched_retained_logic);
   const override = yesNo(schedule.sched_progress_override);
   if (retained && override)
-    invalid3("retained logic and progress override conflict");
+    invalid4("retained logic and progress override conflict");
   if (retained) return "retained_logic";
   if (override) return "progress_override";
   return "actual_dates";
 }
 function nonNegativeNumber(rawValue, field) {
   const value = finiteNumber(rawValue, field);
-  if (value < 0) invalid3(`${field} must be a non-negative number`);
+  if (value < 0) invalid4(`${field} must be a non-negative number`);
   return value;
 }
 function finiteNumber(rawValue, field) {
   const value = Number(rawValue);
   if (rawValue === "" || !Number.isFinite(value)) {
-    invalid3(`${field} must be a finite number`);
+    invalid4(`${field} must be a finite number`);
   }
   return value;
 }
 function nonNegativeInteger(rawValue, field) {
   const value = nonNegativeNumber(rawValue, field);
-  if (!Number.isInteger(value)) invalid3(`${field} must be an integer`);
+  if (!Number.isInteger(value)) invalid4(`${field} must be an integer`);
   return value;
 }
 function endingActivityId(rawValue, resolveActivityId) {
   if (rawValue === "") return null;
   if (resolveActivityId === void 0) {
-    invalid3("ending activity requires an ID resolver");
+    invalid4("ending activity requires an ID resolver");
   }
   const resolved = resolveActivityId(rawValue);
-  if (resolved === null) invalid3(`unknown ending activity "${rawValue}"`);
+  if (resolved === null) invalid4(`unknown ending activity "${rawValue}"`);
   return resolved;
 }
-function invalid3(reason) {
+function invalid4(reason) {
   throw new Error(`${INVALID_OPTIONS}: ${reason}`);
 }
 
@@ -30971,13 +31135,11 @@ function prepareDataDateSettingsUpdate(current, patch) {
   };
 }
 function prepareDataDateActivityUpdate(current, patch, primaryConstraint) {
-  const percentRouted = routeActivityPercentComplete(current, patch);
+  const synchronized = synchronizeNotStartedDurations(current, patch);
+  const percentRouted = routeActivityPercentComplete(current, synchronized);
   validateActivityInputPatch(percentRouted);
   validateSecondaryConstraint(percentRouted, primaryConstraint);
-  const routed = synchronizeNotStartedDurations(
-    current,
-    gatePhysicalPercentInput(current, percentRouted)
-  );
+  const routed = gatePhysicalPercentInput(current, percentRouted);
   const next = cloneDomainValue({
     ...current,
     ...routed,
@@ -30990,7 +31152,7 @@ function prepareDataDateActivityUpdate(current, patch, primaryConstraint) {
   };
 }
 function synchronizeNotStartedDurations(current, patch) {
-  if (current.executionStatus !== P6_EXECUTION_STATUS.NOT_STARTED || patch.remainingDurationHours === void 0 || patch.originalDurationHours !== void 0) {
+  if (current.executionStatus !== P6_EXECUTION_STATUS.NOT_STARTED || patch.actualStart != null || patch.activityPercentComplete !== void 0 || patch.remainingDurationHours === void 0 || patch.originalDurationHours !== void 0) {
     return patch;
   }
   return {
@@ -31035,7 +31197,7 @@ function routeActivityPercentComplete(current, patch) {
     case P6_PERCENT_COMPLETE_TYPE.DURATION:
       return {
         ...rest,
-        remainingDurationHours: current.originalDurationHours * (1 - activityPercentComplete / FULL_PERCENT)
+        remainingDurationHours: (rest.originalDurationHours ?? current.originalDurationHours) * (1 - activityPercentComplete / FULL_PERCENT)
       };
     case P6_PERCENT_COMPLETE_TYPE.UNITS:
       throw new Error(
@@ -37210,136 +37372,6 @@ function serializeP6State(input) {
 // src/boundary/save/unsaved.ts
 var getUnsavedActivities = (activities = []) => (activities ?? []).filter((activity) => !activity.proplannerId);
 
-// src/p6/lookahead-progress-transition.ts
-var LookaheadActualTransitionError = class extends Error {
-  constructor(code) {
-    super(code);
-    this.code = code;
-    this.name = "LookaheadActualTransitionError";
-  }
-  code;
-};
-var ACTUAL_DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
-function resolveLookaheadActualDateSelection(input) {
-  if (!validDate(input.timeSource)) invalid4("INVALID_ACTUAL_TIME_SOURCE");
-  const parts = actualDayParts(input.selectedDay);
-  const [year, month, day] = parts;
-  const result = new Date(input.timeSource);
-  result.setUTCFullYear(year, month - 1, day);
-  if (!sameUtcDay2(result, parts)) invalid4("INVALID_ACTUAL_DAY");
-  return result;
-}
-function actualDayParts(value) {
-  const match = ACTUAL_DAY_PATTERN.exec(value);
-  if (!match) invalid4("INVALID_ACTUAL_DAY");
-  return [Number(match[1]), Number(match[2]), Number(match[3])];
-}
-function planLookaheadProgressActuals(input) {
-  validateInput(input);
-  if (input.dataDate === null) {
-    return { start: null, finish: null, uncomplete: null };
-  }
-  const start = input.activity.executionStatus === P6_EXECUTION_STATUS.NOT_STARTED && input.nextProgress > NOT_STARTED_PROGRESS ? { required: true, suggestedAt: new Date(input.dataDate) } : null;
-  const finish = input.activity.executionStatus !== P6_EXECUTION_STATUS.COMPLETED && input.nextProgress === COMPLETED_PROGRESS ? {
-    optional: true,
-    suggestedAt: input.displayedFinish ? new Date(input.displayedFinish) : null
-  } : null;
-  const uncomplete = input.activity.executionStatus === P6_EXECUTION_STATUS.COMPLETED && input.activity.actualFinish !== null && input.nextProgress < COMPLETED_PROGRESS ? {
-    required: true,
-    removes: new Date(input.activity.actualFinish)
-  } : null;
-  return { start, finish, uncomplete };
-}
-function prepareLookaheadProgressActuals(input) {
-  const plan = planLookaheadProgressActuals(input);
-  if (input.dataDate === null && hasIntent(input.intent)) {
-    invalid4("DATA_DATE_INACTIVE");
-  }
-  if (plan.start && input.intent?.actualStart === void 0) {
-    invalid4("ACTUAL_START_REQUIRED");
-  }
-  if (input.intent?.actualFinish instanceof Date && input.nextProgress !== COMPLETED_PROGRESS) {
-    invalid4("ACTUAL_FINISH_REQUIRES_100");
-  }
-  if (plan.uncomplete && input.intent?.actualFinish !== null) {
-    invalid4("ACTUAL_FINISH_REMOVAL_REQUIRED");
-  }
-  if (!plan.uncomplete && input.intent?.actualFinish === null) {
-    invalid4("ACTUAL_FINISH_REMOVAL_NOT_APPLICABLE");
-  }
-  const actuals = normalizeP6ActualDatePatch(
-    input.activity,
-    input.intent ?? {}
-  );
-  if (input.dataDate === null) return actuals;
-  return withMirroredPercent(input.activity, actuals, input.nextProgress);
-}
-function prepareLookaheadProgressActualsForPersistence(input) {
-  const { resolveCalendar, ...progressInput } = input;
-  const preparedActuals = prepareLookaheadProgressActuals(progressInput);
-  if (input.dataDate === null) {
-    return preparedActuals;
-  }
-  const actualStart = input.intent?.actualStart;
-  const needsActualStartNormalization = actualStart !== void 0 && isUtcMidnight(actualStart);
-  if (!needsActualStartNormalization) return preparedActuals;
-  const intent = normalizeActualStart(input.intent, resolveCalendar);
-  if (intent === void 0) {
-    return preparedActuals;
-  }
-  return prepareLookaheadProgressActuals({ ...progressInput, intent });
-}
-function normalizeActualStart(intent, resolveCalendar) {
-  if (intent?.actualStart === void 0) return intent;
-  if (!isUtcMidnight(intent.actualStart)) return intent;
-  const calendar = resolveCalendar();
-  if (calendar === null) {
-    invalid4("ACTIVITY_CALENDAR_REQUIRED");
-  }
-  return {
-    ...intent,
-    actualStart: defaultActualStartTime(intent.actualStart, calendar)
-  };
-}
-function withMirroredPercent(activity, actuals, nextProgress) {
-  const executionStatus = actuals.executionStatus ?? activity.executionStatus;
-  if (executionStatus !== P6_EXECUTION_STATUS.IN_PROGRESS) return actuals;
-  switch (activity.percentCompleteType) {
-    case P6_PERCENT_COMPLETE_TYPE.PHYSICAL:
-      return { ...actuals, physicalPercentComplete: nextProgress };
-    case P6_PERCENT_COMPLETE_TYPE.DURATION:
-      return {
-        ...actuals,
-        remainingDurationHours: activity.originalDurationHours * (1 - nextProgress / COMPLETED_PROGRESS)
-      };
-    default:
-      return actuals;
-  }
-}
-function validateInput(input) {
-  if (!Number.isFinite(input.nextProgress) || input.nextProgress < NOT_STARTED_PROGRESS || input.nextProgress > COMPLETED_PROGRESS) {
-    invalid4("INVALID_PROGRESS");
-  }
-  if (input.dataDate !== null && !validDate(input.dataDate)) {
-    invalid4("INVALID_DATA_DATE");
-  }
-  if (input.displayedFinish != null && !validDate(input.displayedFinish)) {
-    invalid4("INVALID_DISPLAYED_FINISH");
-  }
-}
-function validDate(value) {
-  return value instanceof Date && Number.isFinite(value.getTime());
-}
-function sameUtcDay2(value, [year, month, day]) {
-  return value.getUTCFullYear() === year && value.getUTCMonth() === month - 1 && value.getUTCDate() === day;
-}
-function hasIntent(intent) {
-  return intent?.actualStart !== void 0 || intent?.actualFinish !== void 0;
-}
-function invalid4(code) {
-  throw new LookaheadActualTransitionError(code);
-}
-
 // src/p6/expected-finish-selection.ts
 function resolveExpectedFinishDateSelection(input) {
   return resolveLookaheadActualDateSelection({