@outbuild-company/schedule-core 1.9.2 → 1.9.4

package/dist/index.js

@@ -338,6 +338,10 @@ var FIELD_REGISTRY = {
     valueKind: "number",
     extract: (activity) => activity.expectedProgressBaseline
   },
+  expectedProgress: {
+    valueKind: "number",
+    extract: (activity) => activity.expectedProgress
+  },
   baselineDurationDays: {
     valueKind: "number",
     extract: (activity) => activity.baselineSnapshot?.durationDays ?? null
@@ -444,12 +448,20 @@ function matchNumber(value, target, operator) {
   if (operator === "lessOrEqual") return value <= target;
   return false;
 }
+function matchNumberBetween(value, minimum, maximum) {
+  return typeof value === "number" && value >= minimum && value <= maximum;
+}
 function matchDate(value, target, operator) {
   if (!(value instanceof Date)) return false;
   if (operator === "after") return value.getTime() > target.getTime();
   if (operator === "before") return value.getTime() < target.getTime();
   return false;
 }
+function matchDateBetween(value, minimum, maximum) {
+  if (!(value instanceof Date)) return false;
+  const time = value.getTime();
+  return time >= minimum.getTime() && time <= maximum.getTime();
+}
 function matchIdArray(value, allowed, operator) {
   const ids = Array.isArray(value) ? value : [];
   const intersects = ids.some((id) => allowed.has(String(id)));
@@ -472,6 +484,23 @@ function matchCriterion(activity, criterion, context) {
   if (descriptor === null) return false;
   const value = descriptor.extract(activity, context);
   const { operator } = criterion;
+  if (operator === "between") {
+    if (descriptor.valueKind === "number") {
+      return matchNumberBetween(
+        value,
+        Number(criterion.value),
+        Number(criterion.valueTo)
+      );
+    }
+    if (descriptor.valueKind === "date") {
+      return matchDateBetween(
+        value,
+        toTargetDate(criterion.value),
+        toTargetDate(criterion.valueTo)
+      );
+    }
+    return false;
+  }
   if (descriptor.valueKind === "string") {
     return matchString(value, String(criterion.value), operator);
   }
@@ -651,9 +680,10 @@ var OPERATORS_BY_KIND = {
     "greaterThan",
     "lessThan",
     "greaterOrEqual",
-    "lessOrEqual"
+    "lessOrEqual",
+    "between"
   ]),
-  date: /* @__PURE__ */ new Set(["after", "before"]),
+  date: /* @__PURE__ */ new Set(["after", "before", "between"]),
   "id-array": /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
   enum: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
   boolean: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
@@ -684,6 +714,9 @@ function normalizeCriterion(criterion) {
   if (!OPERATORS_BY_KIND[descriptor.valueKind].has(criterion.operator)) {
     return { ok: false, reason: "unknown_operator" };
   }
+  if (criterion.operator === "between") {
+    return normalizeBetweenCriterion(criterion, descriptor.valueKind);
+  }
   if (descriptor.valueKind === "number") {
     const value = normalizeNumberValue(criterion.value);
     return value === null ? { ok: false, reason: "invalid_value" } : {
@@ -724,6 +757,31 @@ function normalizeCriterion(criterion) {
   }
   return { ok: true, criterion };
 }
+function normalizeBetweenCriterion(criterion, valueKind) {
+  if (valueKind === "number") {
+    const value = normalizeNumberValue(criterion.value);
+    const valueTo = normalizeNumberValue(criterion.valueTo);
+    if (value === null || valueTo === null || value > valueTo) {
+      return { ok: false, reason: "invalid_value" };
+    }
+    return {
+      ok: true,
+      criterion: { ...criterion, value, valueTo }
+    };
+  }
+  if (valueKind === "date") {
+    const value = normalizeDateValue(criterion.value);
+    const valueTo = normalizeDateValue(criterion.valueTo);
+    if (value === null || valueTo === null || value.getTime() > valueTo.getTime()) {
+      return { ok: false, reason: "invalid_value" };
+    }
+    return {
+      ok: true,
+      criterion: { ...criterion, value, valueTo }
+    };
+  }
+  return { ok: false, reason: "unknown_operator" };
+}
 function validateValueForKind(criterion, valueKind) {
   const { value } = criterion;
   if (valueKind === "boolean") {
@@ -12541,28 +12599,6 @@ function assertValidAssignments(assignments, entityName, readCurrent, ownerByBac
     );
   }
 }
-function assertValidReconciledProgress(entries, deps) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const id = String(entry.activityId);
-    if (id.length === 0 || seen.has(id)) {
-      throw new Error(
-        `persistence-acknowledge: duplicate or empty reconciled activity id "${id}"`
-      );
-    }
-    if (!Number.isFinite(entry.progress) || entry.progress < 0 || entry.progress > 100) {
-      throw new Error(
-        `persistence-acknowledge: invalid reconciled progress ${String(entry.progress)} for "${id}"`
-      );
-    }
-    if (!deps.adapter.getActivity(id)) {
-      throw new Error(
-        `persistence-acknowledge: unknown reconciled activity id "${id}"`
-      );
-    }
-    seen.add(id);
-  }
-}
 async function applyReconciledProgress(entries, deps) {
   const progressToApply = entries.filter((entry) => {
     const current = deps.adapter.getActivity(String(entry.activityId));
@@ -12593,19 +12629,25 @@ async function applyReconciledProgress(entries, deps) {
 async function dispatchPersistenceAcknowledge(action, deps) {
   const activities = action.activities ?? [];
   const links = action.links ?? [];
-  const reconciledProgress = action.reconciledProgress ?? [];
-  assertValidReconciledProgress(reconciledProgress, deps);
   const currentActivities = deps.adapter.getAllActivities();
   const currentLinks = deps.adapter.getAllLinks();
-  const activityOwnerByBackendId = persistedOwnersOf(currentActivities);
-  const linkOwnerByBackendId = persistedOwnersOf(currentLinks);
+  const checkpointActivities = action.checkpoint?.activities ?? currentActivities;
+  const checkpointLinks = action.checkpoint?.links ?? currentLinks;
+  const checkpointActivityById = new Map(
+    checkpointActivities.map((activity) => [String(activity.id), activity])
+  );
+  const checkpointLinkById = new Map(
+    checkpointLinks.map((link) => [String(link.id), link])
+  );
+  const activityOwnerByBackendId = persistedOwnersOf(checkpointActivities);
+  const linkOwnerByBackendId = persistedOwnersOf(checkpointLinks);
   assertValidAssignments(
     activities,
     "activity",
     (id) => {
-      const activity = deps.adapter.getActivity(id);
+      const activity = checkpointActivityById.get(id);
       return {
-        exists: activity !== null,
+        exists: activity !== void 0,
         current: activity?.proplannerId ?? null
       };
     },
@@ -12615,17 +12657,21 @@ async function dispatchPersistenceAcknowledge(action, deps) {
     links,
     "link",
     (id) => {
-      const link = deps.adapter.getLink(id);
-      return { exists: link !== null, current: link?.proplannerId ?? null };
+      const link = checkpointLinkById.get(id);
+      return {
+        exists: link !== void 0,
+        current: link?.proplannerId ?? null
+      };
     },
     linkOwnerByBackendId
   );
-  assertAllNewEntitiesAcknowledged(currentActivities, activities, "activity");
-  assertAllNewEntitiesAcknowledged(currentLinks, links, "link");
-  const activityChanges = await applyReconciledProgress(
-    reconciledProgress,
-    deps
+  assertAllNewEntitiesAcknowledged(
+    checkpointActivities,
+    activities,
+    "activity"
   );
+  assertAllNewEntitiesAcknowledged(checkpointLinks, links, "link");
+  const activityChanges = [];
   const linkChanges = [];
   deps.adapter.batchUpdate(() => {
     for (const assignment of activities) {
@@ -18439,7 +18485,9 @@ function mergeCoalesced(top, next) {
   return buildUndoEntry(changeSet);
 }
 function getDispatchHistoryPolicy(action) {
-  if (action.kind === "persistence-acknowledge") return "clear-on-success";
+  if (action.kind === "persistence-acknowledge") {
+    return "checkpoint-on-success";
+  }
   if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "activity-clipboard-clear" || action.kind === "activity-copy" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
     return "skip";
   }
@@ -18695,22 +18743,25 @@ var UndoRecorder = class _UndoRecorder {
   maxDepth;
   undoStack = [];
   redoStack = [];
+  sequence = 0;
   _lastKey = null;
   _lastTime = 0;
   fork() {
     const fork = new _UndoRecorder(this.maxDepth);
     fork.undoStack.push(...cloneDomainValue(this.undoStack));
     fork.redoStack.push(...cloneDomainValue(this.redoStack));
+    fork.sequence = this.sequence;
     fork._lastKey = this._lastKey;
     fork._lastTime = this._lastTime;
     return fork;
   }
   record(entry, coalesceKey = null, now = 0) {
     const top = this.undoStack[this.undoStack.length - 1];
-    if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top, entry)) {
-      this.undoStack[this.undoStack.length - 1] = mergeCoalesced(top, entry);
+    if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top.entry, entry)) {
+      top.entry = mergeCoalesced(top.entry, entry);
+      top.touchedAt = this.touch();
     } else {
-      this.undoStack.push(entry);
+      this.undoStack.push({ entry, touchedAt: this.touch() });
       if (this.undoStack.length > this.maxDepth) {
         this.undoStack.splice(0, this.undoStack.length - this.maxDepth);
       }
@@ -18723,16 +18774,16 @@ var UndoRecorder = class _UndoRecorder {
     this._lastKey = null;
   }
   takeUndo() {
-    return this.undoStack.pop() ?? null;
+    return this.undoStack.pop()?.entry ?? null;
   }
   takeRedo() {
-    return this.redoStack.pop() ?? null;
+    return this.redoStack.pop()?.entry ?? null;
   }
   pushRedo(entry) {
-    this.redoStack.push(entry);
+    this.redoStack.push({ entry, touchedAt: this.touch() });
   }
   pushUndo(entry) {
-    this.undoStack.push(entry);
+    this.undoStack.push({ entry, touchedAt: this.touch() });
   }
   canUndo() {
     return this.undoStack.length > 0;
@@ -18743,11 +18794,64 @@ var UndoRecorder = class _UndoRecorder {
   undoDepth() {
     return this.undoStack.length;
   }
+  capturePersistenceBoundary() {
+    this.resetCoalesce();
+    return this.sequence;
+  }
+  discardThrough(boundary) {
+    this.removeEntriesThrough(this.undoStack, boundary);
+    this.removeEntriesThrough(this.redoStack, boundary);
+    this.resetCoalesce();
+  }
+  applyPersistedIdentities(activities, links) {
+    const activityIds = new Map(
+      activities.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    const linkIds = new Map(
+      links.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    for (const stored of [...this.undoStack, ...this.redoStack]) {
+      stored.entry = this.withPersistedIdentities(
+        stored.entry,
+        activityIds,
+        linkIds
+      );
+    }
+  }
   clear() {
     this.undoStack.length = 0;
     this.redoStack.length = 0;
     this.resetCoalesce();
   }
+  touch() {
+    this.sequence += 1;
+    return this.sequence;
+  }
+  removeEntriesThrough(stack, boundary) {
+    const retained = stack.filter(({ touchedAt }) => touchedAt > boundary);
+    stack.splice(0, stack.length, ...retained);
+  }
+  withPersistedIdentities(entry, activityIds, linkIds) {
+    const patchActivities = (snapshots) => snapshots === void 0 ? void 0 : new Map(
+      Array.from(snapshots, ([id, activity]) => [
+        id,
+        activityIds.has(id) ? { ...activity, proplannerId: activityIds.get(id) } : activity
+      ])
+    );
+    const patchLinks = (snapshots) => snapshots === void 0 ? void 0 : new Map(
+      Array.from(snapshots, ([id, link]) => [
+        id,
+        linkIds.has(id) ? { ...link, proplannerId: linkIds.get(id) } : link
+      ])
+    );
+    return {
+      ...entry,
+      beforeSnap: patchActivities(entry.beforeSnap),
+      afterSnap: patchActivities(entry.afterSnap),
+      beforeLinks: patchLinks(entry.beforeLinks),
+      afterLinks: patchLinks(entry.afterLinks)
+    };
+  }
 };
 
 // src/dispatch/shared/resequenced-parents.ts
@@ -18905,10 +19009,12 @@ function snapshotFieldValue(field, value) {
   return value;
 }
 function activityChangedSince(current, saved) {
-  for (const field of PERSISTABLE_ACTIVITY_FIELDS) {
-    if (!fieldEquals(field, current[field], saved[field])) return true;
-  }
-  return false;
+  return changedPersistableActivityFields(current, saved).length > 0;
+}
+function changedPersistableActivityFields(current, saved) {
+  return PERSISTABLE_ACTIVITY_FIELDS.filter(
+    (field) => !fieldEquals(field, current[field], saved[field])
+  );
 }
 function fieldEquals(field, currentValue, savedValue) {
   if (DATE_FIELDS2.has(field)) return dateEquals(currentValue, savedValue);
@@ -19017,11 +19123,60 @@ var SaveTracker = class _SaveTracker {
     }
     this.initialized = true;
   }
-  acknowledge(activities, links) {
+  acknowledge(activities, links, activityIdentities = [], linkIdentities = [], currentActivities, currentLinks) {
     if (!this.trackingEnabled) return;
-    assertValidPersistedIdentities(activities, links);
-    this.snapshotActivities(activities);
-    this.snapshotLinks(links);
+    const activityIds = new Map(
+      activityIdentities.map(({ id, proplannerId }) => [
+        String(id),
+        proplannerId
+      ])
+    );
+    const linkIds = new Map(
+      linkIdentities.map(({ id, proplannerId }) => [String(id), proplannerId])
+    );
+    const persistedActivities = activities.map((activity) => ({
+      ...activity,
+      proplannerId: activityIds.get(String(activity.id)) ?? activity.proplannerId
+    }));
+    const persistedLinks = links.map((link) => {
+      const proplannerId = linkIds.get(String(link.id));
+      return proplannerId === void 0 ? { ...link } : { ...link, proplannerId };
+    });
+    assertValidPersistedIdentities(persistedActivities, persistedLinks);
+    this.snapshotActivities(persistedActivities);
+    this.snapshotLinks(persistedLinks);
+    if (!currentActivities || !currentLinks) return;
+    const currentActivityById = new Map(
+      currentActivities.map((activity) => [String(activity.id), activity])
+    );
+    const currentLinkById = new Map(
+      currentLinks.map((link) => [String(link.id), link])
+    );
+    for (const activity of persistedActivities) {
+      const activityId = String(activity.id);
+      if (this.activityIsDirty(
+        activityId,
+        currentActivityById.get(activityId) ?? null
+      )) {
+        this.dirtyActivityIds.add(activityId);
+      }
+    }
+    for (const activity of currentActivities) {
+      const activityId = String(activity.id);
+      if (this.activityIsDirty(activityId, activity)) {
+        this.dirtyActivityIds.add(activityId);
+      }
+    }
+    for (const link of persistedLinks) {
+      const linkId = String(link.id);
+      if (this.linkIsDirty(linkId, currentLinkById.get(linkId) ?? null)) {
+        this.dirtyLinkIds.add(linkId);
+      }
+    }
+    for (const link of currentLinks) {
+      const linkId = String(link.id);
+      if (this.linkIsDirty(linkId, link)) this.dirtyLinkIds.add(linkId);
+    }
   }
   snapshotActivities(activities) {
     if (!this.trackingEnabled) return;
@@ -19205,6 +19360,21 @@ var SaveTracker = class _SaveTracker {
     }
     return modified;
   }
+  modifiedActivityFields(getActivity) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.trackingEnabled || !this.initialized) return result;
+    for (const activityId of this.dirtyActivityIds) {
+      const current = getActivity(activityId);
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (!current || !saved) continue;
+      const fields = changedPersistableActivityFields(
+        current,
+        saved.persistable
+      );
+      if (fields.length > 0) result.set(activityId, fields);
+    }
+    return result;
+  }
   modifiedLinks(getLink) {
     if (!this.trackingEnabled || !this.initialized) return [];
     const modified = [];
@@ -21297,6 +21467,14 @@ var ScheduleCore = class _ScheduleCore {
       (activityId) => this.coreRuntime.state.getActivity(activityId)
     ).map(cloneDomainValue);
   }
+  getModifiedActivityFields() {
+    this.assertReady();
+    return cloneDomainValue(
+      this._saveTracker.modifiedActivityFields(
+        (activityId) => this.coreRuntime.state.getActivity(activityId)
+      )
+    );
+  }
   getNewActivities() {
     this.assertReady();
     return this._saveTracker.newActivities(
@@ -21310,6 +21488,10 @@ var ScheduleCore = class _ScheduleCore {
   getScheduleRevision() {
     return this._scheduleRevision;
   }
+  capturePersistenceHistoryBoundary() {
+    this.assertReady();
+    return this._undo.capturePersistenceBoundary();
+  }
   getCanonicalDigest() {
     this.assertReady();
     const byId = (left, right) => String(left.id).localeCompare(String(right.id));
@@ -21480,12 +21662,29 @@ var ScheduleCore = class _ScheduleCore {
       );
     }
     if (result.ok) {
-      if (historyPolicy === "clear-on-success") {
+      if (historyPolicy === "checkpoint-on-success") {
+        if (action.kind !== "persistence-acknowledge") {
+          throw new Error(
+            "checkpoint-on-success requires persistence acknowledge"
+          );
+        }
+        const currentActivities = this.coreRuntime.state.getAllActivities();
+        const currentLinks = this.coreRuntime.state.getAllLinks();
+        const checkpoint = action.checkpoint;
+        const boundary = checkpoint?.historyBoundary ?? this._undo.capturePersistenceBoundary();
         this._saveTracker.acknowledge(
-          this.coreRuntime.state.getAllActivities(),
-          this.coreRuntime.state.getAllLinks()
+          checkpoint?.activities ?? currentActivities,
+          checkpoint?.links ?? currentLinks,
+          action.activities,
+          action.links,
+          currentActivities,
+          currentLinks
+        );
+        this._undo.discardThrough(boundary);
+        this._undo.applyPersistedIdentities(
+          action.activities ?? [],
+          action.links ?? []
         );
-        this._undo.clear();
       } else if (action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true) {
         this._saveTracker.acknowledgePersistedLookahead(
           result.changes.activities,