@outbuild-company/schedule-core 1.23.0 → 1.25.0

package/dist/index.cjs

@@ -6287,7 +6287,9 @@ var P6_PERCENT_COMPLETE_TYPE = {
 var P6_ACTIVITY_TYPE = {
   TASK: "task",
   LEVEL_OF_EFFORT: "level_of_effort",
-  START_MILESTONE: "start_milestone"};
+  START_MILESTONE: "start_milestone",
+  RESOURCE_DEPENDENT: "resource_dependent"
+};
 var P6_EXECUTION_STATUS = {
   NOT_STARTED: "not_started",
   IN_PROGRESS: "in_progress",
@@ -11979,14 +11981,65 @@ function createOutbuildP6ActivityDraft(activity) {
   if (state === void 0) return void 0;
   return {
     ...state,
-    remainingDurationHours: draftRemainingDuration(activity)
+    ...outbuildProgressExecution(activity, activity.durationHours)
   };
 }
-function draftRemainingDuration(activity) {
+var COMPLETED_PHYSICAL_PERCENT = 100;
+var NOT_STARTED_PHYSICAL_PERCENT = 0;
+function outbuildProgressExecution(activity, originalDurationHours) {
   if (activity.progress === NOT_STARTED_PROGRESS) {
-    return activity.durationHours;
+    return {
+      executionStatus: P6_EXECUTION_STATUS.NOT_STARTED,
+      actualStart: null,
+      actualFinish: null,
+      remainingDurationHours: originalDurationHours,
+      physicalPercentComplete: NOT_STARTED_PHYSICAL_PERCENT,
+      actualDurationHours: 0,
+      atCompletionDurationHours: originalDurationHours,
+      durationPercentComplete: 0
+    };
   }
-  return isCompletedProgress(activity.progress) ? 0 : null;
+  const actualStart = cloneValidDate(activity.startDate, "actualStart");
+  if (isCompletedProgress(activity.progress)) {
+    const hasMeasurableDuration = originalDurationHours > 0;
+    return {
+      executionStatus: P6_EXECUTION_STATUS.COMPLETED,
+      actualStart,
+      actualFinish: cloneValidDate(activity.endDate, "actualFinish"),
+      remainingDurationHours: 0,
+      physicalPercentComplete: COMPLETED_PHYSICAL_PERCENT,
+      actualDurationHours: originalDurationHours,
+      atCompletionDurationHours: originalDurationHours,
+      durationPercentComplete: hasMeasurableDuration ? COMPLETED_PHYSICAL_PERCENT : NOT_STARTED_PHYSICAL_PERCENT
+    };
+  }
+  return {
+    executionStatus: P6_EXECUTION_STATUS.IN_PROGRESS,
+    actualStart,
+    actualFinish: null,
+    remainingDurationHours: originalDurationHours,
+    physicalPercentComplete: activity.progress,
+    actualDurationHours: 0,
+    atCompletionDurationHours: originalDurationHours,
+    durationPercentComplete: 0
+  };
+}
+function awaitsOutbuildExecution(draft) {
+  return draft.executionStatus === P6_EXECUTION_STATUS.NOT_STARTED && draft.actualStart === null;
+}
+function reconcileOutbuildProgress(activity, draft) {
+  const isProgressed = activity.progress !== NOT_STARTED_PROGRESS;
+  if (!isProgressed || !awaitsOutbuildExecution(draft)) return draft;
+  const inferred = outbuildProgressExecution(
+    activity,
+    draft.originalDurationHours
+  );
+  const keepsRecordedRemaining = inferred.executionStatus === P6_EXECUTION_STATUS.IN_PROGRESS && draft.remainingDurationHours !== null;
+  return {
+    ...draft,
+    ...inferred,
+    ...keepsRecordedRemaining ? { remainingDurationHours: draft.remainingDurationHours } : {}
+  };
 }
 
 // src/p6/inactive-drafts.ts
@@ -12039,17 +12092,41 @@ function ordinaryInputChanges(before, activity) {
     ...before.startDate.getTime() !== activity.startDate.getTime() ? { plannedStart: new Date(activity.startDate) } : {},
     ...before.endDate.getTime() !== activity.endDate.getTime() ? { plannedFinish: new Date(activity.endDate) } : {},
     ...durationChanged ? { originalDurationHours: activity.durationHours } : {},
-    ...durationChanged || before.progress !== activity.progress ? remainingInputChanges(before, activity) : {}
+    ...durationChanged || before.progress !== activity.progress ? executionInputChanges(before, activity, durationChanged) : {}
   };
 }
-function remainingInputChanges(before, activity) {
+function executionInputChanges(before, activity, durationChanged) {
   const current = activity.p6;
-  if (current.actualStart !== null || current.remainingDurationHours !== before.p6.remainingDurationHours)
-    return {};
-  const remaining = draftRemainingDuration(activity);
+  const hasExplicitRemainingCorrection = current.remainingDurationHours !== before.p6.remainingDurationHours;
+  if (hasExplicitRemainingCorrection) return {};
+  const progressChanged = before.progress !== activity.progress;
+  const resetsToNotStarted = progressChanged && activity.progress === NOT_STARTED_PROGRESS;
+  if (awaitsOutbuildExecution(current) || resetsToNotStarted) {
+    const originalDurationHours = durationChanged ? activity.durationHours : current.originalDurationHours;
+    return outbuildProgressExecution(activity, originalDurationHours);
+  }
+  const isStarted = current.actualStart !== null;
+  if (!isStarted || !progressChanged) return {};
+  return startedProgressChanges(current, activity);
+}
+function startedProgressChanges(current, activity) {
+  const mirrorsPhysicalPercent = current.percentCompleteType === P6_PERCENT_COMPLETE_TYPE.PHYSICAL;
+  if (!isCompletedProgress(activity.progress)) {
+    return {
+      ...current.actualFinish === null ? {} : {
+        executionStatus: P6_EXECUTION_STATUS.IN_PROGRESS,
+        actualFinish: null
+      },
+      ...mirrorsPhysicalPercent ? { physicalPercentComplete: activity.progress } : {}
+    };
+  }
+  const finishesAfterActualStart = current.actualStart !== null && activity.endDate.getTime() >= current.actualStart.getTime();
+  if (current.actualFinish !== null || !finishesAfterActualStart) return {};
   return {
-    remainingDurationHours: remaining,
-    ...remaining !== null ? { atCompletionDurationHours: remaining } : {}
+    executionStatus: P6_EXECUTION_STATUS.COMPLETED,
+    actualFinish: new Date(activity.endDate),
+    remainingDurationHours: 0,
+    physicalPercentComplete: COMPLETED_PROGRESS
   };
 }
 
@@ -17941,6 +18018,7 @@ var LOAD_DIAGNOSTIC_SAMPLE_LIMIT = 10;
 var LOAD_DIAGNOSTIC_CODE = {
   INVALID_BASELINE_POINT: "invalid_baseline_point",
   UNKNOWN_CONSTRAINT: "unknown_constraint",
+  PROGRESS_OUT_OF_RANGE: "progress_out_of_range",
   ORPHAN_ACTIVITY: "orphan_activity",
   INVALID_LINK: "invalid_link",
   DUPLICATE_LINK: "duplicate_link"
@@ -17948,6 +18026,7 @@ var LOAD_DIAGNOSTIC_CODE = {
 var LOAD_DIAGNOSTIC_CODE_ORDER = [
   LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
   LOAD_DIAGNOSTIC_CODE.UNKNOWN_CONSTRAINT,
+  LOAD_DIAGNOSTIC_CODE.PROGRESS_OUT_OF_RANGE,
   LOAD_DIAGNOSTIC_CODE.ORPHAN_ACTIVITY,
   LOAD_DIAGNOSTIC_CODE.INVALID_LINK,
   LOAD_DIAGNOSTIC_CODE.DUPLICATE_LINK
@@ -24753,12 +24832,21 @@ function normalizePersistedActivityId(rawId) {
   }
   return rawId;
 }
-function parseProgress(raw) {
+function parseProgress(raw, reporter, recordDiagnostic, activityId) {
   const progress = Number(raw);
-  if (!Number.isFinite(progress) || progress < NOT_STARTED_PROGRESS || progress > MAX_TOLERATED_PROGRESS) {
+  if (!Number.isFinite(progress)) {
     throw new TypeError(`invalid activity progress ${String(raw)}`);
   }
-  return progress;
+  const isBelowNotStarted = progress < NOT_STARTED_PROGRESS;
+  const isAboveCompleted = progress > MAX_TOLERATED_PROGRESS;
+  const isWithinRange = !isBelowNotStarted && !isAboveCompleted;
+  if (isWithinRange) return progress;
+  const clamped = isBelowNotStarted ? NOT_STARTED_PROGRESS : COMPLETED_PROGRESS;
+  recordDiagnostic(LOAD_DIAGNOSTIC_CODE.PROGRESS_OUT_OF_RANGE, activityId);
+  reporter.warn(
+    `[parseFromBackend] activity "${activityId}" progress ${String(raw)} is out of range \u2014 clamping to ${clamped}`
+  );
+  return clamped;
 }
 function parseCriticality(raw, reporter) {
   if (typeof raw.is_critical === "boolean") return raw.is_critical;
@@ -24791,7 +24879,12 @@ function parseActivity(raw, context) {
     context.defaultCalendarId
   );
   const inheritedDefaultCalendar = raw.calendarId == null || !context.knownCalendarIds.has(String(raw.calendarId));
-  const progress = parseProgress(raw.progress);
+  const progress = parseProgress(
+    raw.progress,
+    context.reporter,
+    context.recordDiagnostic,
+    String(raw.unique_id)
+  );
   const { constraintType, constraintDate } = resolveConstraint(
     raw,
     context.reporter,
@@ -26245,8 +26338,8 @@ var P6ActivityStatusError = class extends Error {
   }
   code;
 };
-var COMPLETED_PHYSICAL_PERCENT = 100;
-var NOT_STARTED_PHYSICAL_PERCENT = 0;
+var COMPLETED_PHYSICAL_PERCENT2 = 100;
+var NOT_STARTED_PHYSICAL_PERCENT2 = 0;
 function validateP6ActivityStatus(activity) {
   validateRemainingDuration(activity.remainingDurationHours);
   validateDates(activity);
@@ -26272,11 +26365,11 @@ function normalizeP6ActualDatePatch(current, patch) {
     executionStatus,
     ...actualFinish !== null ? {
       remainingDurationHours: 0,
-      physicalPercentComplete: COMPLETED_PHYSICAL_PERCENT
+      physicalPercentComplete: COMPLETED_PHYSICAL_PERCENT2
     } : {},
     ...unStarting ? {
       remainingDurationHours: current.originalDurationHours,
-      physicalPercentComplete: NOT_STARTED_PHYSICAL_PERCENT
+      physicalPercentComplete: NOT_STARTED_PHYSICAL_PERCENT2
     } : {}
   };
   validateP6ActivityDraftStatus({ ...current, ...normalized2 });
@@ -30020,6 +30113,39 @@ 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({
@@ -30133,8 +30259,17 @@ function prepareDataDateSchedule(input) {
     preflight.settings,
     beforeProjectState
   );
+  const rolledExpectedFinishes = planRolledExpectedFinishes({
+    previousSettings: preflight.previousSettings,
+    settings: preflight.settings,
+    activities: preflight.activities
+  });
   const calculated = calculateP6Schedule({
-    adapter: calculationState(input.state, preflight.activities),
+    adapter: calculationState(
+      input.state,
+      preflight.activities,
+      rolledExpectedFinishes
+    ),
     settings: preflight.settings,
     project: {
       projectId: String(input.sector.projectId),
@@ -30180,11 +30315,19 @@ function requireProjectState(projectState) {
     "P6 capability is not enabled for this Schedule"
   );
 }
-function calculationState(current, schedulableActivities) {
+function calculationState(current, schedulableActivities, rolledExpectedFinishes) {
   const state = current.fork();
   state.forEachActivity((activity) => {
-    if (schedulableActivities.has(activity.id)) return;
-    state.setActivityField(activity.id, "p6", void 0);
+    if (!schedulableActivities.has(activity.id)) {
+      state.setActivityField(activity.id, "p6", void 0);
+      return;
+    }
+    const rolledExpectedFinish = rolledExpectedFinishes.get(activity.id);
+    if (rolledExpectedFinish === void 0 || activity.p6 === void 0) return;
+    state.setActivityField(activity.id, "p6", {
+      ...activity.p6,
+      expectedFinish: rolledExpectedFinish
+    });
   });
   return state;
 }
@@ -30309,7 +30452,7 @@ function initializeDataDate(input, activities) {
 function attachImportedDataDate(activities, imported, settings) {
   for (const activity of activities) {
     const importedP6 = Object.hasOwn(imported, activity.id) ? imported[activity.id] : void 0;
-    const p6 = importedP6 ?? createOutbuildP6ActivityDraft(activity);
+    const p6 = importedP6 === void 0 ? createOutbuildP6ActivityDraft(activity) : reconcileOutbuildProgress(activity, importedP6);
     if (p6 === void 0) continue;
     activity.p6 = p6;
     if (!hasActiveDataDate(settings)) continue;