@outbuild-company/schedule-core 1.32.0 → 1.33.0

package/dist/index.cjs

@@ -344,6 +344,7 @@ var DISPATCH_ACTION_KIND = {
   CELL_CLIPBOARD_CLEAR: "cell-clipboard-clear",
   CELL_PASTE_COPIED: "cell-paste-copied",
   PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
+  PERSISTENCE_REBASE: "persistence-rebase",
   BASELINE_APPLY: "baseline-apply",
   PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
   STATUS_CRITERIA_SET: "status-criteria-set",
@@ -789,6 +790,10 @@ function createScheduleNamespaces(engine) {
       acknowledge: (checkpoint) => engine.dispatch({
         kind: DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE,
         checkpoint
+      }),
+      rebase: (remote) => engine.dispatch({
+        kind: DISPATCH_ACTION_KIND.PERSISTENCE_REBASE,
+        remote
       })
     },
     history: {
@@ -2445,6 +2450,7 @@ var ACTIVITY_PROPERTY = {
   DURATION_HOURS: "durationHours",
   CONSTRAINT_TYPE: "constraintType",
   CONSTRAINT_DATE: "constraintDate",
+  AUTO_SCHEDULING: "autoScheduling",
   CALENDAR_ID: "calendarId",
   PROGRESS: "progress",
   COST: "cost",
@@ -2452,7 +2458,9 @@ var ACTIVITY_PROPERTY = {
   REAL_COST: "realCost",
   WORK_HOURS: "workHours",
   REAL_WORK_HOURS: "realWorkHours",
+  PONDERATOR: "ponderator",
   CORRELATIVE_ID: "correlativeId",
+  UNIQUE_CORRELATIVE_ID: "uniqueCorrelativeId",
   CUSTOM_ID: "customId",
   NEW_ACTIVITIES_ARRAY: "newActivityIds",
   HAS_NEW_ACTIVITIES: "hasNewActivities",
@@ -6849,6 +6857,21 @@ function findPipelineForColumn(columnName) {
 }
 
 // src/dispatch/types.ts
+var PERSISTENCE_REBASE_CONFLICT_KIND = {
+  FIELD: "field",
+  DELETED_REMOTELY: "deleted-remotely",
+  DELETED_LOCALLY: "deleted-locally",
+  PARENT_REMOVED: "parent-removed",
+  BECAME_PARENT_REMOTELY: "became-parent-remotely",
+  BECAME_PARENT_LOCALLY: "became-parent-locally",
+  DUPLICATE_LINK: "duplicate-link",
+  ORDER: "order",
+  LINK_CYCLE: "link-cycle"
+};
+var PERSISTENCE_REBASE_ENTITY = {
+  ACTIVITY: "activity",
+  LINK: "link"
+};
 var ACTIVITY_BATCH_MODE = {
   APPEND: "append",
   REPLACE: "replace"
@@ -18894,284 +18917,2184 @@ function normalizeBaselinePoint(point, reporter, diagnostic2, isMilestone = fals
   };
 }
 
-// src/baselines/apply-baseline-points.ts
-function applyBaselinePoints(adapter, points, reporter, recordDiagnostic = noopLoadDiagnosticRecorder) {
-  const idByProplanner = /* @__PURE__ */ new Map();
-  adapter.forEachActivity((a, id) => {
-    const pid = a.proplannerId;
-    if (typeof pid === "number") idByProplanner.set(pid, id);
+// 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 EXCEPTION_TIME_FORMAT_REGEX = /^\d{4}[/-]\d{1,2}[/-]\d{1,2}[ T](\d{1,2}):(\d{2})/;
+var WEEKDAYS_PER_WEEK = 7;
+var EXCEPTION_EVERY_TYPE = {
+  DAILY: "DAILY",
+  WEEKLY: "WEEKLY",
+  MONTHLY: "MONTHLY",
+  YEARLY: "YEARLY"
+};
+var MONTHS_PER_YEAR = 12;
+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 = [];
+  const activities = rawActivities.map((raw) => {
+    const activity = parseActivity(raw, context);
+    if (raw.should_be_showed === false) hiddenIds.push(activity.id);
+    return activity;
   });
-  const grouped = /* @__PURE__ */ new Map();
-  for (const p of points) {
-    const activityId = p.activityId;
-    if (typeof activityId !== "number") {
-      recordDiagnostic(
-        LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
-        String(activityId ?? "unknown")
-      );
-      continue;
-    }
-    const coreId = idByProplanner.get(activityId);
-    if (coreId === void 0) {
-      recordDiagnostic(
-        LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
-        String(activityId)
-      );
-      continue;
-    }
-    const arr = grouped.get(coreId);
-    if (arr) arr.push(p);
-    else grouped.set(coreId, [p]);
-  }
-  const changed2 = [];
-  for (const [coreId, group] of grouped) {
-    const isMilestone = adapter.getActivity(coreId)?.type === ACTIVITY_TYPE.MILESTONE;
-    adapter.setActivityField(
-      coreId,
-      "baselinePoints",
-      group.map(
-        (point) => normalizeBaselinePoint(
-          point,
-          reporter,
-          {
-            record: recordDiagnostic,
-            sampleId: coreId
-          },
-          isMilestone
-        )
-      ).filter((point) => point !== null)
+  forceRootProjectToRoot(activities);
+  const activityIds = new Set(activities.map((activity) => activity.id));
+  reparentOrphansToRoot(
+    activities,
+    activityIds,
+    context.reporter,
+    context.recordDiagnostic
+  );
+  return { activities, activityIds, hiddenIds };
+}
+function parseConstraintLabel(label, reporter, recordDiagnostic, activityId) {
+  if (!label) return null;
+  const normalized2 = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
+  if (normalized2 === void 0) {
+    recordDiagnostic(LOAD_DIAGNOSTIC_CODE.UNKNOWN_CONSTRAINT, activityId);
+    reporter.warn(
+      `[parseFromBackend] unknown constraint label "${label}" \u2014 defaulting to "asap"`
     );
-    changed2.push(coreId);
+    return DEFAULT_CONSTRAINT_TYPE;
   }
-  adapter.forEachActivity((a, id) => {
-    if (grouped.has(id)) return;
-    const existing = a.baselinePoints;
-    if (Array.isArray(existing) && existing.length > 0) {
-      adapter.setActivityField(id, "baselinePoints", []);
-      changed2.push(id);
-    }
-  });
-  return changed2;
+  return normalized2;
 }
-
-// src/baselines/baseline-snapshot.ts
-function buildBaselineSnapshot(activity) {
-  const active = getActiveBaseline(activity);
-  if (!active) return null;
-  return {
-    startDate: active.startDate,
-    endDate: active.endDate,
-    durationDays: active.durationDays,
-    cost: active.cost,
-    workHours: active.workHours
-  };
+function resolveConstraint(raw, reporter, recordDiagnostic) {
+  const constraintType = parseConstraintLabel(
+    raw.constraint,
+    reporter,
+    recordDiagnostic,
+    String(raw.unique_id)
+  );
+  const constraintTakesDate = constraintType !== CONSTRAINT_TYPE.ASAP && constraintType !== CONSTRAINT_TYPE.ALAP;
+  const constraintDate = constraintTakesDate && raw.constraint_date ? parseBackendDate(raw.constraint_date) : null;
+  return { constraintType, constraintDate };
 }
-function emitBaselineSnapshotColumns(state) {
-  const changed2 = [];
-  state.forEachActivity((activity, id) => {
-    const snapshot = buildBaselineSnapshot(activity);
-    if (!snapshot) {
-      if (activity.baselineSnapshot !== null) {
-        state.setActivityField(id, "baselineSnapshot", null);
-        changed2.push(id);
-      }
-      return;
-    }
-    state.setActivityField(id, "baselineSnapshot", snapshot);
-    changed2.push(id);
-  });
-  return changed2;
+function resolveCalendarId(rawCalendarId, knownCalendarIds, defaultCalendarId) {
+  if (rawCalendarId == null) return defaultCalendarId;
+  const coerced = String(rawCalendarId);
+  return knownCalendarIds.has(coerced) ? coerced : defaultCalendarId;
 }
-
-// src/baselines/apply-baseline-overlay.ts
-function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarId = null, recordDiagnostic = noopLoadDiagnosticRecorder) {
-  const changed2 = /* @__PURE__ */ new Set();
-  for (const id of applyBaselinePoints(
-    state,
-    points,
-    reporter,
-    recordDiagnostic
-  )) {
-    changed2.add(id);
+function parseNewActivityIds(raw) {
+  if (raw == null || raw === "") return [];
+  if (Array.isArray(raw)) return raw.map(String);
+  if (typeof raw !== "string") return [];
+  try {
+    const parsed2 = JSON.parse(raw);
+    return Array.isArray(parsed2) ? parsed2.map(String) : [];
+  } catch {
+    return [];
   }
-  if (now) {
-    for (const id of runExpectedProgressBase(state, now, defaultBaseCalendarId))
-      changed2.add(id);
+}
+function hasUsableId(entry) {
+  if (typeof entry !== "object" || entry === null) return false;
+  if (!("id" in entry)) return false;
+  const value = entry.id;
+  return typeof value === "string" || typeof value === "number";
+}
+function parseIdList(raw) {
+  if (!Array.isArray(raw)) return [];
+  const ids = [];
+  for (const entry of raw) {
+    if (hasUsableId(entry)) ids.push(String(entry.id));
   }
-  for (const id of emitBaselineSnapshotColumns(state)) changed2.add(id);
-  for (const id of emitRealCost(state)) changed2.add(id);
-  return [...changed2];
+  return ids;
 }
-
-// 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, basisById);
-    }
-  });
+function parseParentId(rawParentId) {
+  return rawParentId === ROOT_PARENT_ID ? null : String(rawParentId);
 }
-
-// src/dispatch/shared/baseline-weighted-fields.ts
-function recomputeBaselineWeightedFields(deps, criterion) {
-  recomputeAllPonderators(criterion, deps.adapter);
-  recomputeAllProgressRollup(deps.adapter, criterion);
-  if (deps.now) {
-    runExpectedProgressBase(
-      deps.adapter,
-      deps.now,
-      deps.defaultBaseCalendarId ?? null
-    );
-    applyExpectedProgressLive(deps.adapter, deps.now);
+function normalizePersistedActivityId(rawId) {
+  if (rawId == null) return null;
+  const isValidIdentity = typeof rawId === "number" && (rawId === 0 || Number.isSafeInteger(rawId) && rawId > 0);
+  if (!isValidIdentity) {
+    throw new Error(`invalid activity proplannerId ${String(rawId)}`);
   }
-  emitRealCost(deps.adapter);
-  if (deps.now) applyStatusPass(deps.adapter, deps.sector.statusCriteria);
+  return rawId;
 }
-
-// src/dispatch/handlers/baseline-apply.ts
-function activeBaselineSignature(deps) {
-  return JSON.stringify(
-    deps.adapter.getAllIds().map((id) => {
-      const point = deps.adapter.getActivity(id)?.baselinePoints.find((candidate) => candidate.isActiveVersion);
-      return point ? [
-        String(id),
-        point.versionId,
-        point.startDate?.getTime() ?? null,
-        point.endDate?.getTime() ?? null,
-        point.durationDays,
-        point.cost,
-        point.workHours,
-        point.baseCalendarId,
-        point.hoursPerDay,
-        point.hoursPerWeek
-      ] : [String(id), null];
-    })
+function parseProgress(raw, reporter, recordDiagnostic, activityId) {
+  const progress = Number(raw);
+  if (!Number.isFinite(progress)) {
+    throw new TypeError(`invalid activity progress ${String(raw)}`);
+  }
+  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;
 }
-async function dispatchBaselineApply(action, deps) {
-  const beforeSnap = await snapshotActivities(
-    deps.adapter,
-    new Set(deps.adapter.getAllIds())
+function parseCriticality(raw, reporter) {
+  if (typeof raw.is_critical === "boolean") return raw.is_critical;
+  reporter.error(
+    "[parseFromBackend] invalid activity is_critical \u2014 defaulting to false",
+    new TypeError(
+      `activity "${raw.unique_id}" received ${typeof raw.is_critical}`
+    )
   );
-  const activeBaselineBefore = activeBaselineSignature(deps);
-  const changedIds = applyBaselineOverlay(
-    deps.adapter,
-    action.points,
-    deps.now,
-    deps.reporter,
-    deps.defaultBaseCalendarId ?? null,
-    void 0
+  return false;
+}
+function parseBaselinePoints(raw, reporter, recordDiagnostic, activityId, isMilestone) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map(
+    (point) => normalizeBaselinePoint(
+      point,
+      reporter,
+      {
+        record: recordDiagnostic,
+        sampleId: activityId
+      },
+      isMilestone
+    )
+  ).filter((point) => point !== null);
+}
+function parseActivity(raw, context) {
+  const calendarId = resolveCalendarId(
+    raw.calendarId,
+    context.knownCalendarIds,
+    context.defaultCalendarId
   );
-  applyBaselineVariancePass(deps.adapter, deps.sector.hoursPerDay);
-  applyRoleBaselineVariancePass(deps.adapter, deps.sector.hoursPerDay);
-  if (activeBaselineSignature(deps) !== activeBaselineBefore) {
-    recomputeBaselineWeightedFields(
-      deps,
-      deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
-    );
-  }
+  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 {
-    ok: true,
-    changes: await assembleChangeSet(deps.adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds: changedIds,
-      scheduledIds: [],
-      hoursPerDay: deps.sector.hoursPerDay
-    })
+    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,
+    projectBaselineVarianceDays: null,
+    primaryBaselineVarianceDays: 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
   };
 }
-
-// src/dispatch/handlers/ponderator-criterion-set.ts
-function isValidCriterion(value) {
-  return Object.values(ACTIVITY_PONDERATOR_CRITERION).includes(
-    value
+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;
 }
-async function dispatchPonderatorCriterionSet(action, deps) {
-  if (!isValidCriterion(action.criterion)) {
-    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+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;
+    }
   }
-  const allIds = new Set(deps.adapter.getAllIds());
-  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
-  recomputeBaselineWeightedFields(deps, action.criterion);
-  deps.sector.activityCreter = action.criterion;
-  return {
-    ok: true,
-    changes: await assembleChangeSet(deps.adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds: allIds,
-      scheduledIds: [],
-      hoursPerDay: deps.sector.hoursPerDay
-    })
-  };
 }
 
-// src/dispatch/handlers/status-criteria-set.ts
-async function dispatchStatusCriteriaSet(action, deps) {
-  const resolved = resolveStatusCriteria(action.criteria);
-  const allIds = new Set(deps.adapter.getAllIds());
-  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
-  const changedIds = applyStatusPass(deps.adapter, resolved);
-  deps.sector.statusCriteria = resolved;
-  return {
-    ok: true,
-    changes: await assembleChangeSet(deps.adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds: changedIds,
-      scheduledIds: [],
-      hoursPerDay: deps.sector.hoursPerDay
-    })
-  };
+// src/boundary/backend/normalize-link.ts
+function resolveLinkType(rawType) {
+  if (typeof rawType !== "string") return null;
+  const fromLabel = parseLinkTypeCode(rawType);
+  if (fromLabel) return fromLabel;
+  if (isLinkType(rawType)) return rawType;
+  return null;
 }
-
-// src/dispatch/handlers/calendar-reconcile.ts
-async function dispatchCalendarReconcile(action, options, deps) {
-  const beforeSnap = /* @__PURE__ */ new Map();
-  const touchedIds = /* @__PURE__ */ new Set();
-  for (const activity of deps.adapter.getAllActivities()) {
-    if (!shouldReconcile(activity, deps)) continue;
-    const calendar = deps.ctx.calendars.getCalendar(activity.calendarId);
-    if (!calendar) continue;
-    const startReference = calendar.isWorkTime(
-      activity.startDate,
-      CALENDAR_UNIT.HOUR
-    ) ? startOfUtcDay4(activity.startDate) : activity.startDate;
-    const startDate = calendar.getClosestWorkTime({
-      date: startReference,
-      direction: WORK_TIME_DIRECTION.FUTURE,
-      unit: CALENDAR_UNIT.HOUR
-    });
-    const endDate = calendar.calculateEndDate(
-      startDate,
-      activity.durationHours
-    );
-    if (sameInstant(startDate, activity.startDate) && sameInstant(endDate, activity.endDate)) {
-      continue;
-    }
-    const activityId = String(activity.id);
-    beforeSnap.set(activityId, structuredCloneActivity(activity));
-    touchedIds.add(activityId);
-    deps.adapter.setActivityFields(activityId, { startDate, endDate });
+function normalizePersistedLinkId(rawId) {
+  if (rawId == null) return void 0;
+  const isValidIdentity = typeof rawId === "number" && (rawId === 0 || Number.isSafeInteger(rawId) && rawId > 0);
+  if (!isValidIdentity) {
+    throw new Error(`invalid link proplannerId ${String(rawId)}`);
   }
-  const { scheduledIds } = await runPostMutation(
-    {
-      adapter: deps.adapter,
-      scheduler: deps.scheduler,
-      sector: deps.sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId,
-      runAutomaticP6Schedule: deps.runAutomaticP6Schedule
-    },
-    {
-      action,
-      autoscheduleFrom: AUTOSCHEDULE_SCOPE.ROOTS,
-      recomputeParentsFrom: touchedIds,
+  return rawId;
+}
+function normalizeLinks(rawLinks, context) {
+  const parsedLinks = [];
+  for (const rawLink of rawLinks) {
+    try {
+      parsedLinks.push(
+        parseLink(rawLink, context.knownActivityIds, context.hoursPerDay)
+      );
+    } catch (parseError2) {
+      context.recordDiagnostic(
+        LOAD_DIAGNOSTIC_CODE.INVALID_LINK,
+        String(rawLink.unique_id ?? rawLink.id)
+      );
+      context.reporter.warn(
+        "[parseFromBackend] dropping invalid link",
+        parseError2
+      );
+    }
+  }
+  return dedupeLinksBySignature(parsedLinks, context.recordDiagnostic);
+}
+function parseLink(link, activityIds, hoursPerDay) {
+  const id = String(link.unique_id ?? link.id);
+  const source = String(link.source_id ?? link.source ?? "");
+  const target = String(link.target_id ?? link.target ?? "");
+  if (!activityIds.has(source)) {
+    throw new Error(
+      `[parseFromBackend] link "${id}" source "${source}" does not exist`
+    );
+  }
+  if (!activityIds.has(target)) {
+    throw new Error(
+      `[parseFromBackend] link "${id}" target "${target}" does not exist`
+    );
+  }
+  const type = resolveLinkType(link.type);
+  if (type === null) {
+    throw new Error(
+      `[parseFromBackend] link "${id}" has invalid type "${String(link.type)}"`
+    );
+  }
+  const ganttIdRaw = link.ganttId;
+  const sectorIdRaw = link.sectorId;
+  const proplannerId = normalizePersistedLinkId(link.id);
+  return {
+    id,
+    source,
+    target,
+    type,
+    lag: lagDaysToHours(Number(link.lag ?? 0), hoursPerDay),
+    freeSlackHours: null,
+    isCritical: false,
+    ...typeof ganttIdRaw === "number" ? { ganttId: ganttIdRaw } : {},
+    ...typeof sectorIdRaw === "number" ? { sectorId: sectorIdRaw } : {},
+    ...proplannerId === void 0 ? {} : { proplannerId }
+  };
+}
+function dedupeLinksBySignature(links, recordDiagnostic) {
+  const bySignature = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const signature = `${link.source}-${link.target}-${link.type}`;
+    const existing = bySignature.get(signature);
+    if (!existing) {
+      bySignature.set(signature, link);
+      continue;
+    }
+    const incomingWins = linkIdAsNumber(link) > linkIdAsNumber(existing);
+    const discarded = incomingWins ? existing : link;
+    recordDiagnostic(LOAD_DIAGNOSTIC_CODE.DUPLICATE_LINK, discarded.id);
+    if (incomingWins) {
+      bySignature.set(signature, link);
+    }
+  }
+  return [...bySignature.values()];
+}
+function linkIdAsNumber(link) {
+  const numeric = Number(link.id);
+  return Number.isFinite(numeric) ? numeric : -Infinity;
+}
+
+// src/boundary/save/field-policy.ts
+var SAVE_FIELD_POLICY = {
+  TRACKED: "tracked",
+  IGNORED: "ignored"
+};
+
+// src/boundary/save/activity-changes.ts
+var ACTIVITY_SAVE_FIELD_POLICY = {
+  id: SAVE_FIELD_POLICY.IGNORED,
+  proplannerId: SAVE_FIELD_POLICY.IGNORED,
+  parentId: SAVE_FIELD_POLICY.TRACKED,
+  name: SAVE_FIELD_POLICY.TRACKED,
+  description: SAVE_FIELD_POLICY.TRACKED,
+  type: SAVE_FIELD_POLICY.TRACKED,
+  startDate: SAVE_FIELD_POLICY.TRACKED,
+  endDate: SAVE_FIELD_POLICY.TRACKED,
+  durationHours: SAVE_FIELD_POLICY.TRACKED,
+  constraintType: SAVE_FIELD_POLICY.TRACKED,
+  constraintDate: SAVE_FIELD_POLICY.TRACKED,
+  autoScheduling: SAVE_FIELD_POLICY.TRACKED,
+  calendarId: SAVE_FIELD_POLICY.TRACKED,
+  assignedDefaultCalendar: SAVE_FIELD_POLICY.IGNORED,
+  dateOrigin: SAVE_FIELD_POLICY.TRACKED,
+  progress: SAVE_FIELD_POLICY.TRACKED,
+  cost: SAVE_FIELD_POLICY.TRACKED,
+  usedCost: SAVE_FIELD_POLICY.TRACKED,
+  realCost: SAVE_FIELD_POLICY.TRACKED,
+  workHours: SAVE_FIELD_POLICY.TRACKED,
+  realWorkHours: SAVE_FIELD_POLICY.TRACKED,
+  ponderator: SAVE_FIELD_POLICY.TRACKED,
+  hasCustomPonderator: SAVE_FIELD_POLICY.TRACKED,
+  correlativeId: SAVE_FIELD_POLICY.TRACKED,
+  uniqueCorrelativeId: SAVE_FIELD_POLICY.TRACKED,
+  customId: SAVE_FIELD_POLICY.TRACKED,
+  subcontractId: SAVE_FIELD_POLICY.TRACKED,
+  isLookahead: SAVE_FIELD_POLICY.TRACKED,
+  hasLookaheadTasks: SAVE_FIELD_POLICY.IGNORED,
+  newActivityIds: SAVE_FIELD_POLICY.TRACKED,
+  hasNewActivities: SAVE_FIELD_POLICY.TRACKED,
+  isNewActivity: SAVE_FIELD_POLICY.IGNORED,
+  pendingRequestIds: SAVE_FIELD_POLICY.IGNORED,
+  responsableIds: SAVE_FIELD_POLICY.TRACKED,
+  tagIds: SAVE_FIELD_POLICY.TRACKED,
+  baselinePoints: SAVE_FIELD_POLICY.IGNORED,
+  baselineSnapshot: SAVE_FIELD_POLICY.IGNORED,
+  recursiveDurationHours: SAVE_FIELD_POLICY.IGNORED,
+  isCritical: SAVE_FIELD_POLICY.IGNORED,
+  freeSlackHours: SAVE_FIELD_POLICY.IGNORED,
+  calendarDuration: SAVE_FIELD_POLICY.IGNORED,
+  baselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
+  projectBaselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
+  primaryBaselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
+  expectedProgress: SAVE_FIELD_POLICY.IGNORED,
+  expectedProgressBaseline: SAVE_FIELD_POLICY.IGNORED,
+  status: SAVE_FIELD_POLICY.IGNORED,
+  criticalPath: SAVE_FIELD_POLICY.IGNORED,
+  p6: SAVE_FIELD_POLICY.IGNORED
+};
+var PERSISTABLE_ACTIVITY_FIELDS = Object.keys(ACTIVITY_SAVE_FIELD_POLICY).filter((field) => {
+  return ACTIVITY_SAVE_FIELD_POLICY[field] === SAVE_FIELD_POLICY.TRACKED;
+});
+var DATE_FIELDS = /* @__PURE__ */ new Set([
+  "startDate",
+  "endDate",
+  "constraintDate",
+  "dateOrigin"
+]);
+var ID_ARRAY_FIELDS = /* @__PURE__ */ new Set([
+  "newActivityIds",
+  "responsableIds",
+  "tagIds"
+]);
+function projectPersistableActivity(activity) {
+  const entries = PERSISTABLE_ACTIVITY_FIELDS.map(
+    (field) => [field, snapshotFieldValue(field, activity[field])]
+  );
+  return Object.fromEntries(entries);
+}
+function snapshotFieldValue(field, value) {
+  if (DATE_FIELDS.has(field)) {
+    return value instanceof Date ? new Date(value) : null;
+  }
+  if (ID_ARRAY_FIELDS.has(field)) {
+    return Array.isArray(value) ? [...value] : [];
+  }
+  return value;
+}
+function activityChangedSince(current, saved) {
+  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_FIELDS.has(field)) return dateEquals(currentValue, savedValue);
+  if (ID_ARRAY_FIELDS.has(field))
+    return idArrayEquals(currentValue, savedValue);
+  return (currentValue ?? null) === (savedValue ?? null);
+}
+function dateEquals(current, saved) {
+  const currentTime = current instanceof Date ? current.getTime() : null;
+  const savedTime = saved instanceof Date ? saved.getTime() : null;
+  return currentTime === savedTime;
+}
+function idArrayEquals(current, saved) {
+  const currentIds = new Set(Array.isArray(current) ? current.map(String) : []);
+  const savedIds = new Set(Array.isArray(saved) ? saved.map(String) : []);
+  if (currentIds.size !== savedIds.size) return false;
+  for (const currentId of currentIds) {
+    if (!savedIds.has(currentId)) return false;
+  }
+  return true;
+}
+
+// src/boundary/save/link-changes.ts
+var LINK_SAVE_FIELD_POLICY = {
+  id: SAVE_FIELD_POLICY.IGNORED,
+  source: SAVE_FIELD_POLICY.TRACKED,
+  target: SAVE_FIELD_POLICY.TRACKED,
+  type: SAVE_FIELD_POLICY.TRACKED,
+  lag: SAVE_FIELD_POLICY.TRACKED,
+  freeSlackHours: SAVE_FIELD_POLICY.IGNORED,
+  isCritical: SAVE_FIELD_POLICY.IGNORED,
+  ganttId: SAVE_FIELD_POLICY.IGNORED,
+  sectorId: SAVE_FIELD_POLICY.IGNORED,
+  proplannerId: SAVE_FIELD_POLICY.IGNORED
+};
+var TRACKED_LINK_FIELDS = Object.keys(LINK_SAVE_FIELD_POLICY).filter((field) => {
+  return LINK_SAVE_FIELD_POLICY[field] === SAVE_FIELD_POLICY.TRACKED;
+});
+function linkChangedSince(baseline, current) {
+  return TRACKED_LINK_FIELDS.some(
+    (field) => baseline[field] !== current[field]
+  );
+}
+function checkNoUpdatedLinks(baseline, current) {
+  const baselineById = new Map(
+    baseline.map((link) => [String(link.id), link])
+  );
+  return current.filter((link) => {
+    const base = baselineById.get(String(link.id));
+    if (!base) return false;
+    return linkChangedSince(base, link);
+  });
+}
+
+// src/dispatch/handlers/persistence-rebase-topology.ts
+var parentKeyOf2 = (parentId) => isRootParent(parentId) ? null : String(parentId);
+function mergedParents(input) {
+  const parents = /* @__PURE__ */ new Map();
+  for (const local of input.localActivities) {
+    parents.set(String(local.id), parentKeyOf2(local.parentId));
+  }
+  for (const created of input.createActivities) {
+    parents.set(String(created.id), parentKeyOf2(created.parentId));
+  }
+  for (const update of input.updateActivities) {
+    if (update.fields.parentId === void 0) continue;
+    parents.set(update.activityId, parentKeyOf2(update.fields.parentId));
+  }
+  for (const removedId of input.removeActivityIds) parents.delete(removedId);
+  return parents;
+}
+function findParentCycle(parents) {
+  const settled = /* @__PURE__ */ new Set();
+  for (const start of parents.keys()) {
+    const path = [];
+    const onPath = /* @__PURE__ */ new Set();
+    let current = start;
+    while (current !== null && current !== void 0 && !settled.has(current)) {
+      if (onPath.has(current)) return path.slice(path.indexOf(current));
+      onPath.add(current);
+      path.push(current);
+      current = parents.get(current);
+    }
+    for (const visited of path) settled.add(visited);
+  }
+  return null;
+}
+function restoreRemoteParent(activityId, remote, input) {
+  const existing = input.updateActivities.find(
+    (update) => update.activityId === activityId
+  );
+  if (existing) {
+    const index = input.updateActivities.indexOf(existing);
+    input.updateActivities[index] = {
+      activityId,
+      fields: { ...existing.fields, parentId: remote.parentId }
+    };
+    return;
+  }
+  input.updateActivities.push({
+    activityId,
+    fields: { parentId: remote.parentId }
+  });
+}
+function repairParentCycles(input) {
+  const remoteById = new Map(
+    input.remoteActivities.map((remote) => [String(remote.id), remote])
+  );
+  const conflicts = [];
+  let parents = mergedParents(input);
+  let cycle = findParentCycle(parents);
+  while (cycle !== null) {
+    const localChoice = cycle.find((activityId) => {
+      const remote2 = remoteById.get(activityId);
+      return remote2 !== void 0 && parentKeyOf2(remote2.parentId) !== parents.get(activityId);
+    });
+    const remote = localChoice === void 0 ? void 0 : remoteById.get(localChoice);
+    if (localChoice === void 0 || remote === void 0) break;
+    conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+      id: localChoice,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.FIELD,
+      field: ACTIVITY_PROPERTY.PARENT,
+      mine: parents.get(localChoice) ?? null,
+      theirs: parentKeyOf2(remote.parentId)
+    });
+    restoreRemoteParent(localChoice, remote, input);
+    parents = mergedParents(input);
+    cycle = findParentCycle(parents);
+  }
+  return conflicts;
+}
+function cyclicActivityCount(adapter) {
+  const edges = projectEffectiveEdges(adapter, adapter.getAllLinks());
+  return circularComponents(edges).reduce(
+    (total, component) => total + component.length,
+    0
+  );
+}
+function breakDependencyCycles(adapter, localLinkIdsInCreationOrder, changes) {
+  const removed = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  if (cyclicActivityCount(adapter) === 0) return { conflicts, removed };
+  const withdrawn = [];
+  for (const linkId of localLinkIdsInCreationOrder) {
+    const link = adapter.getLink(linkId);
+    if (!link) continue;
+    withdrawn.push({ ...link });
+    adapter.removeLink(linkId);
+  }
+  let cyclic = cyclicActivityCount(adapter);
+  for (const link of withdrawn) {
+    adapter.addLink(link);
+    const withLink = cyclicActivityCount(adapter);
+    if (withLink <= cyclic) {
+      cyclic = withLink;
+      continue;
+    }
+    adapter.removeLink(String(link.id));
+    removed.set(String(link.id), link);
+    conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.LINK,
+      id: String(link.id),
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.LINK_CYCLE,
+      field: null,
+      mine: snapshotToLink(link),
+      theirs: null
+    });
+  }
+  changes.push(...buildLinkDeletions(new Map(removed)));
+  return { conflicts, removed };
+}
+
+// src/dispatch/handlers/persistence-rebase-plan.ts
+var ORDER_FIELDS = /* @__PURE__ */ new Set([
+  ACTIVITY_PROPERTY.CORRELATIVE_ID,
+  ACTIVITY_PROPERTY.UNIQUE_CORRELATIVE_ID
+]);
+var RECOMPUTED_FIELDS = /* @__PURE__ */ new Set([
+  ACTIVITY_PROPERTY.END_DATE
+]);
+var RECOMPUTED_PARENT_FIELDS = /* @__PURE__ */ new Set(
+  [
+    ACTIVITY_PROPERTY.START_DATE,
+    ACTIVITY_PROPERTY.DURATION_HOURS,
+    ACTIVITY_PROPERTY.COST,
+    ACTIVITY_PROPERTY.USED_COST,
+    ACTIVITY_PROPERTY.WORK_HOURS
+  ]
+);
+var FOLLOWS_REMOTE_FIELDS = /* @__PURE__ */ new Set([
+  ACTIVITY_PROPERTY.REAL_WORK_HOURS,
+  ACTIVITY_PROPERTY.HAS_NEW_ACTIVITIES
+]);
+var PARENT_DERIVED_FIELDS = /* @__PURE__ */ new Set([
+  ...RECOMPUTED_PARENT_FIELDS,
+  ACTIVITY_PROPERTY.PROGRESS,
+  ACTIVITY_PROPERTY.TYPE,
+  ACTIVITY_PROPERTY.REAL_COST,
+  ACTIVITY_PROPERTY.PONDERATOR,
+  ACTIVITY_PROPERTY.AUTO_SCHEDULING
+]);
+var UNION_MERGED_FIELDS = /* @__PURE__ */ new Set([
+  ACTIVITY_PROPERTY.NEW_ACTIVITIES_ARRAY
+]);
+function planPersistenceRebase(input) {
+  const plan = {
+    createActivities: [],
+    updateActivities: [],
+    removeActivityIds: [],
+    createLinks: [],
+    updateLinks: [],
+    removeLinkIds: [],
+    remoteChanges: [],
+    conflicts: []
+  };
+  planActivities(input, plan);
+  plan.conflicts.push(
+    ...repairParentCycles({
+      localActivities: input.localActivities,
+      remoteActivities: input.remoteActivities,
+      createActivities: plan.createActivities,
+      removeActivityIds: plan.removeActivityIds,
+      updateActivities: plan.updateActivities
+    })
+  );
+  planLinks(input, plan);
+  return plan;
+}
+function collectParentIds2(activities) {
+  const parentIds = /* @__PURE__ */ new Set();
+  for (const activity of activities) {
+    if (isRootParent(activity.parentId)) continue;
+    parentIds.add(String(activity.parentId));
+  }
+  return parentIds;
+}
+function collectLinkTargetIds(links) {
+  return new Set(links.map((link) => String(link.target)));
+}
+function indexStructure(input) {
+  return {
+    localParentIds: collectParentIds2(input.localActivities),
+    remoteParentIds: collectParentIds2(input.remoteActivities),
+    localTargetIds: collectLinkTargetIds(input.localLinks),
+    remoteTargetIds: collectLinkTargetIds(input.remoteLinks)
+  };
+}
+function mergeContextFor(activityId, structure) {
+  return {
+    local: {
+      isParent: structure.localParentIds.has(activityId),
+      hasPredecessors: structure.localTargetIds.has(activityId)
+    },
+    remote: {
+      isParent: structure.remoteParentIds.has(activityId),
+      hasPredecessors: structure.remoteTargetIds.has(activityId)
+    }
+  };
+}
+function isRecomputedOnSide(field, side, activity) {
+  if (RECOMPUTED_FIELDS.has(field)) return true;
+  if (side.isParent && RECOMPUTED_PARENT_FIELDS.has(field)) return true;
+  const isScheduledStart = field === ACTIVITY_PROPERTY.START_DATE && side.hasPredecessors && activity.autoScheduling;
+  if (isScheduledStart) return true;
+  return field === ACTIVITY_PROPERTY.PONDERATOR && !activity.hasCustomPonderator;
+}
+function isDerivedOnSide(field, side, activity) {
+  if (isRecomputedOnSide(field, side, activity)) return true;
+  if (FOLLOWS_REMOTE_FIELDS.has(field)) return true;
+  return side.isParent && PARENT_DERIVED_FIELDS.has(field);
+}
+function sourceEditsOf(activity, base, side) {
+  if (base === null) return /* @__PURE__ */ new Set();
+  return new Set(
+    changedPersistableActivityFields(activity, base).filter(
+      (field) => !isDerivedOnSide(field, side, activity)
+    )
+  );
+}
+function planActivities(input, plan) {
+  const structure = indexStructure(input);
+  const localById = new Map(
+    input.localActivities.map((activity) => [String(activity.id), activity])
+  );
+  const remoteIds = /* @__PURE__ */ new Set();
+  for (const remote of input.remoteActivities) {
+    const activityId = String(remote.id);
+    remoteIds.add(activityId);
+    const base = input.checkpoint.checkpointActivity(activityId);
+    const local = localById.get(activityId) ?? null;
+    const context = mergeContextFor(activityId, structure);
+    planRemoteActivity(activityId, remote, base, local, context, plan);
+  }
+  for (const activityId of input.checkpoint.checkpointActivityIds()) {
+    if (remoteIds.has(activityId)) continue;
+    const local = localById.get(activityId);
+    if (!local) continue;
+    const base = input.checkpoint.checkpointActivity(activityId);
+    planRemotelyDeletedActivity(activityId, base, local, plan);
+  }
+}
+function planRemoteActivity(activityId, remote, base, local, context, plan) {
+  if (base === null) {
+    if (local === null) {
+      plan.createActivities.push(remote);
+      return;
+    }
+    planActivityFields(activityId, remote, null, local, context, plan);
+    return;
+  }
+  const remoteFields = changedPersistableActivityFields(remote, base);
+  if (local === null) {
+    if (remoteFields.length === 0) return;
+    plan.createActivities.push(remote);
+    plan.conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+      id: activityId,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.DELETED_LOCALLY,
+      field: null,
+      mine: null,
+      theirs: projectPersistableActivity(remote)
+    });
+    return;
+  }
+  planActivityFields(activityId, remote, base, local, context, plan);
+}
+var MERGE_SIDE = { LOCAL: "local", REMOTE: "remote" };
+function typeSideOf(context) {
+  if (context.local.isParent) return MERGE_SIDE.LOCAL;
+  if (context.remote.isParent) return MERGE_SIDE.REMOTE;
+  return null;
+}
+function winningSide(merge, field) {
+  const remoteChanged = merge.remoteFields.includes(field);
+  const localChanged = merge.localChangedFields.has(field);
+  if (field === ACTIVITY_PROPERTY.TYPE) {
+    if (!localChanged) return MERGE_SIDE.REMOTE;
+    if (!remoteChanged) return MERGE_SIDE.LOCAL;
+    return typeSideOf(merge.context) ?? MERGE_SIDE.REMOTE;
+  }
+  if (isRecomputedOnSide(field, merge.context.local, merge.local)) {
+    return MERGE_SIDE.REMOTE;
+  }
+  if (!localChanged) return MERGE_SIDE.REMOTE;
+  if (merge.remoteSourceFields.has(field)) return MERGE_SIDE.REMOTE;
+  const isParentOnBothSides = merge.context.local.isParent && merge.context.remote.isParent;
+  const followsRemote = FOLLOWS_REMOTE_FIELDS.has(field) || isParentOnBothSides && PARENT_DERIVED_FIELDS.has(field);
+  if (remoteChanged && followsRemote) return MERGE_SIDE.REMOTE;
+  return MERGE_SIDE.LOCAL;
+}
+function planActivityFields(activityId, remote, base, local, context, plan) {
+  const localPersistable = projectPersistableActivity(local);
+  const remotePersistable = projectPersistableActivity(remote);
+  const differsFromLocal = changedPersistableActivityFields(
+    remote,
+    localPersistable
+  );
+  if (differsFromLocal.length === 0) return;
+  const remoteFields = base === null ? differsFromLocal : changedPersistableActivityFields(remote, base);
+  const merge = {
+    activityId,
+    remote,
+    local,
+    remotePersistable,
+    localPersistable,
+    remoteFields,
+    localFields: sourceEditsOf(local, base, context.local),
+    localChangedFields: new Set(
+      base === null ? [] : changedPersistableActivityFields(local, base)
+    ),
+    remoteSourceFields: base === null ? new Set(differsFromLocal) : sourceEditsOf(remote, base, context.remote),
+    context
+  };
+  planBecameParentConflicts(merge, plan);
+  const fields = mergeFields(merge, differsFromLocal, plan);
+  if (Object.keys(fields).length === 0) return;
+  plan.updateActivities.push({ activityId, fields });
+}
+function mergeFields(merge, differsFromLocal, plan) {
+  const { remotePersistable } = merge;
+  const fields = {};
+  for (const field of differsFromLocal) {
+    if (ORDER_FIELDS.has(field) || field === ACTIVITY_PROPERTY.AUTO_SCHEDULING) {
+      continue;
+    }
+    if (UNION_MERGED_FIELDS.has(field)) {
+      mergeUnionField(merge, field, fields);
+      continue;
+    }
+    if (field === ACTIVITY_PROPERTY.HAS_NEW_ACTIVITIES && fields.hasNewActivities !== void 0) {
+      continue;
+    }
+    if (winningSide(merge, field) === MERGE_SIDE.LOCAL) continue;
+    Reflect.set(fields, field, remotePersistable[field]);
+    if (merge.remoteSourceFields.has(field)) {
+      reportSourceField(merge, field, plan);
+    }
+  }
+  if (fields.progress !== void 0 && !merge.context.local.isParent) {
+    fields.autoScheduling = isAutoSchedulingEnabledForProgress(fields.progress);
+  }
+  keepMilestoneDurationConsistent(merge, fields, plan);
+  return fields;
+}
+function mergeUnionField(merge, field, fields) {
+  const { localPersistable, remotePersistable } = merge;
+  const merged = unionOfIds(localPersistable[field], remotePersistable[field]);
+  Reflect.set(fields, field, merged);
+  Reflect.set(
+    fields,
+    ACTIVITY_PROPERTY.HAS_NEW_ACTIVITIES,
+    merged.length > 0 || localPersistable.hasNewActivities || remotePersistable.hasNewActivities
+  );
+}
+function keepMilestoneDurationConsistent(merge, fields, plan) {
+  const finalType = fields.type ?? merge.local.type;
+  const finalDuration = fields.durationHours ?? merge.local.durationHours;
+  if (finalType !== ACTIVITY_TYPE.MILESTONE || finalDuration === 0) return;
+  const remoteSetDuration = fields.durationHours !== void 0;
+  const field = remoteSetDuration ? ACTIVITY_PROPERTY.TYPE : ACTIVITY_PROPERTY.DURATION_HOURS;
+  if (remoteSetDuration) {
+    fields.type = merge.remote.type;
+  } else {
+    fields.durationHours = 0;
+  }
+  plan.conflicts.push({
+    entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+    id: merge.activityId,
+    kind: PERSISTENCE_REBASE_CONFLICT_KIND.FIELD,
+    field,
+    mine: merge.localPersistable[field],
+    theirs: remoteSetDuration ? merge.remote.type : 0
+  });
+}
+function reportSourceField(merge, field, plan) {
+  const mine = merge.localPersistable[field];
+  const theirs = merge.remotePersistable[field];
+  if (merge.localFields.has(field)) {
+    plan.conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+      id: merge.activityId,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.FIELD,
+      field,
+      mine,
+      theirs
+    });
+    return;
+  }
+  plan.remoteChanges.push({
+    entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+    id: merge.activityId,
+    field,
+    before: mine,
+    after: theirs
+  });
+}
+function unionOfIds(mine, theirs) {
+  const merged = /* @__PURE__ */ new Set();
+  for (const value of Array.isArray(mine) ? mine : [])
+    merged.add(String(value));
+  for (const value of Array.isArray(theirs) ? theirs : [])
+    merged.add(String(value));
+  return [...merged];
+}
+function leafValuesOf(fields, activity) {
+  const picked = {};
+  for (const field of fields) {
+    if (!PARENT_DERIVED_FIELDS.has(field)) continue;
+    if (field === ACTIVITY_PROPERTY.TYPE) continue;
+    Reflect.set(picked, field, activity[field]);
+  }
+  return picked;
+}
+function planBecameParentConflicts(merge, plan) {
+  const { context, localPersistable, remotePersistable } = merge;
+  if (context.local.isParent === context.remote.isParent) return;
+  const droppedLeafValues = context.remote.isParent ? leafValuesOf(merge.localFields, localPersistable) : leafValuesOf(merge.remoteFields, remotePersistable);
+  if (Object.keys(droppedLeafValues).length === 0) return;
+  const conflict = context.remote.isParent ? {
+    kind: PERSISTENCE_REBASE_CONFLICT_KIND.BECAME_PARENT_REMOTELY,
+    mine: droppedLeafValues,
+    theirs: remotePersistable
+  } : {
+    kind: PERSISTENCE_REBASE_CONFLICT_KIND.BECAME_PARENT_LOCALLY,
+    mine: localPersistable,
+    theirs: droppedLeafValues
+  };
+  plan.conflicts.push({
+    entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+    id: merge.activityId,
+    field: null,
+    ...conflict
+  });
+}
+function planRemotelyDeletedActivity(activityId, base, local, plan) {
+  plan.removeActivityIds.push(activityId);
+  const localEdited = base !== null && changedPersistableActivityFields(local, base).length > 0;
+  if (!localEdited) return;
+  plan.conflicts.push({
+    entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+    id: activityId,
+    kind: PERSISTENCE_REBASE_CONFLICT_KIND.DELETED_REMOTELY,
+    field: null,
+    mine: projectPersistableActivity(local),
+    theirs: null
+  });
+}
+function planLinks(input, plan) {
+  const localById = new Map(
+    input.localLinks.map((link) => [String(link.id), link])
+  );
+  const remoteIds = /* @__PURE__ */ new Set();
+  const createdRemotely = [];
+  for (const remote of input.remoteLinks) {
+    const linkId = String(remote.id);
+    remoteIds.add(linkId);
+    const base = input.checkpoint.checkpointLink(linkId);
+    const local = localById.get(linkId) ?? null;
+    if (base === null && local === null) createdRemotely.push(remote);
+    planRemoteLink(linkId, remote, base, local, plan);
+  }
+  for (const linkId of input.checkpoint.checkpointLinkIds()) {
+    if (remoteIds.has(linkId)) continue;
+    const local = localById.get(linkId);
+    if (!local) continue;
+    const base = input.checkpoint.checkpointLink(linkId);
+    planRemotelyDeletedLink(linkId, base, local, plan);
+  }
+  planDuplicateLinks(input, createdRemotely, remoteIds, plan);
+}
+function endpointPairKey(link) {
+  return [String(link.source), String(link.target)].sort().join("|");
+}
+function planDuplicateLinks(input, createdRemotely, remoteIds, plan) {
+  if (createdRemotely.length === 0) return;
+  const remoteByPair = new Map(
+    createdRemotely.map((remote) => [endpointPairKey(remote), remote])
+  );
+  for (const local of input.localLinks) {
+    const linkId = String(local.id);
+    const isUnsavedLocally = !remoteIds.has(linkId) && input.checkpoint.checkpointLink(linkId) === null;
+    if (!isUnsavedLocally) continue;
+    const remote = remoteByPair.get(endpointPairKey(local));
+    if (!remote) continue;
+    plan.removeLinkIds.push(linkId);
+    const mine = persistableLinkOf(local);
+    const theirs = persistableLinkOf(remote);
+    if (changedLinkFields(mine, theirs).length === 0) continue;
+    plan.conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.LINK,
+      id: String(remote.id),
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.DUPLICATE_LINK,
+      field: null,
+      mine,
+      theirs
+    });
+  }
+}
+function changedLinkFields(current, saved) {
+  return TRACKED_LINK_FIELDS.filter((field) => current[field] !== saved[field]);
+}
+function planRemoteLink(linkId, remote, base, local, plan) {
+  if (base === null) {
+    if (local === null) {
+      plan.createLinks.push(remote);
+      return;
+    }
+    planLinkFields(linkId, remote, null, local, plan);
+    return;
+  }
+  if (local === null) {
+    if (changedLinkFields(remote, base).length === 0) return;
+    plan.createLinks.push(remote);
+    plan.conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.LINK,
+      id: linkId,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.DELETED_LOCALLY,
+      field: null,
+      mine: null,
+      theirs: persistableLinkOf(remote)
+    });
+    return;
+  }
+  planLinkFields(linkId, remote, base, local, plan);
+}
+function persistableLinkOf(link) {
+  return {
+    source: String(link.source),
+    target: String(link.target),
+    type: link.type,
+    lag: Number(link.lag)
+  };
+}
+function planLinkFields(linkId, remote, base, local, plan) {
+  const remoteLink = persistableLinkOf(remote);
+  const localLink = persistableLinkOf(local);
+  const remoteFields = base === null ? changedLinkFields(remoteLink, localLink) : changedLinkFields(remoteLink, base);
+  if (remoteFields.length === 0) return;
+  const localFields = new Set(
+    base === null ? [] : changedLinkFields(localLink, base)
+  );
+  const differsFromLocal = new Set(
+    changedLinkFields(remoteLink, localLink)
+  );
+  const fields = {};
+  for (const field of remoteFields) {
+    if (!differsFromLocal.has(field)) continue;
+    Reflect.set(fields, field, remoteLink[field]);
+    if (localFields.has(field)) {
+      plan.conflicts.push({
+        entity: PERSISTENCE_REBASE_ENTITY.LINK,
+        id: linkId,
+        kind: PERSISTENCE_REBASE_CONFLICT_KIND.FIELD,
+        field,
+        mine: localLink[field],
+        theirs: remoteLink[field]
+      });
+      continue;
+    }
+    plan.remoteChanges.push({
+      entity: PERSISTENCE_REBASE_ENTITY.LINK,
+      id: linkId,
+      field,
+      before: localLink[field],
+      after: remoteLink[field]
+    });
+  }
+  if (Object.keys(fields).length === 0) return;
+  plan.updateLinks.push({ linkId, fields });
+}
+function planRemotelyDeletedLink(linkId, base, local, plan) {
+  plan.removeLinkIds.push(linkId);
+  const localEdited = base !== null && changedLinkFields(persistableLinkOf(local), base).length > 0;
+  if (!localEdited) return;
+  plan.conflicts.push({
+    entity: PERSISTENCE_REBASE_ENTITY.LINK,
+    id: linkId,
+    kind: PERSISTENCE_REBASE_CONFLICT_KIND.DELETED_REMOTELY,
+    field: null,
+    mine: persistableLinkOf(local),
+    theirs: null
+  });
+}
+
+// src/dispatch/handlers/persistence-rebase-order.ts
+var parentKeyOf3 = (parentId) => isRootParent(parentId) ? ROOT_PARENT_ID : String(parentId);
+var sortValueOf = (correlativeId) => {
+  const value = Number(correlativeId);
+  return Number.isFinite(value) ? value : Number.MAX_SAFE_INTEGER;
+};
+function siblingOrdersOf(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = parentKeyOf3(entry.parentId);
+    const siblings = grouped.get(key) ?? [];
+    siblings.push(entry);
+    grouped.set(key, siblings);
+  }
+  const orders = /* @__PURE__ */ new Map();
+  for (const [key, siblings] of grouped) {
+    siblings.sort(
+      (left, right) => sortValueOf(left.correlativeId) - sortValueOf(right.correlativeId) || left.id.localeCompare(right.id)
+    );
+    orders.set(
+      key,
+      siblings.map((entry) => entry.id)
+    );
+  }
+  return orders;
+}
+var entryOf = (activity) => ({
+  id: String(activity.id),
+  parentId: activity.parentId,
+  correlativeId: activity.correlativeId
+});
+function captureSiblingOrders(localActivities, remoteActivities, checkpoint) {
+  const baseEntries = [];
+  for (const activityId of checkpoint.checkpointActivityIds()) {
+    const saved = checkpoint.checkpointActivity(activityId);
+    if (saved === null) continue;
+    baseEntries.push({
+      id: activityId,
+      parentId: saved.parentId,
+      correlativeId: saved.correlativeId
+    });
+  }
+  return {
+    local: siblingOrdersOf(localActivities.map(entryOf)),
+    remote: siblingOrdersOf(remoteActivities.map(entryOf)),
+    base: siblingOrdersOf(baseEntries)
+  };
+}
+function isReordered(side, base) {
+  const inBase = new Set(base);
+  const inSide = new Set(side);
+  const sideCommon = side.filter((activityId) => inBase.has(activityId));
+  const baseCommon = base.filter((activityId) => inSide.has(activityId));
+  return sideCommon.some(
+    (activityId, index) => baseCommon[index] !== activityId
+  );
+}
+function weave(primary, secondary, members) {
+  const merged = primary.filter((activityId) => members.has(activityId));
+  let anchorIndex = -1;
+  for (const activityId of secondary) {
+    const placedAt = merged.indexOf(activityId);
+    if (placedAt !== -1) {
+      anchorIndex = placedAt;
+      continue;
+    }
+    if (!members.has(activityId)) continue;
+    merged.splice(anchorIndex + 1, 0, activityId);
+    anchorIndex += 1;
+  }
+  for (const activityId of members) {
+    if (!merged.includes(activityId)) merged.push(activityId);
+  }
+  return merged;
+}
+function planParentOrder(parentKey, members, sources) {
+  const local = sources.local.get(parentKey) ?? [];
+  const remote = sources.remote.get(parentKey) ?? [];
+  const base = sources.base.get(parentKey) ?? [];
+  const localReordered = isReordered(local, base);
+  const remoteReordered = isReordered(remote, base);
+  const keepsLocalOrder = localReordered && !remoteReordered;
+  const order = keepsLocalOrder ? weave(local, remote, members) : weave(remote, local, members);
+  const overridesLocalOrder = localReordered && remoteReordered && isReordered(local, order);
+  return {
+    order,
+    conflict: overridesLocalOrder ? {
+      entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+      id: parentKey,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.ORDER,
+      field: ACTIVITY_PROPERTY.CORRELATIVE_ID,
+      mine: local.filter((activityId) => members.has(activityId)),
+      theirs: order
+    } : null
+  };
+}
+function currentSiblings(adapter) {
+  return siblingOrdersOf(adapter.getAllActivities().map(entryOf));
+}
+function applySiblingOrder(adapter, sources) {
+  const { orders, conflicts } = planSiblingOrders(adapter, sources);
+  return { shifts: renumberCorrelatives(adapter, orders), conflicts };
+}
+function planSiblingOrders(adapter, sources) {
+  const orders = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  for (const [parentKey, siblings] of currentSiblings(adapter)) {
+    const planned = planParentOrder(parentKey, new Set(siblings), sources);
+    orders.set(parentKey, planned.order);
+    if (planned.conflict !== null) conflicts.push(planned.conflict);
+  }
+  return { orders, conflicts };
+}
+function renumberCorrelatives(adapter, orders) {
+  const shifts = [];
+  let counter = 0;
+  const pending = [...orders.get(ROOT_PARENT_ID) ?? []].reverse();
+  while (pending.length > 0) {
+    const activityId = pending.pop();
+    if (activityId === void 0) break;
+    const shift = writeCorrelative(adapter, activityId, counter);
+    if (shift !== null) shifts.push(shift);
+    counter += 1;
+    pushChildrenInReverse(pending, orders.get(activityId) ?? []);
+  }
+  return shifts;
+}
+function writeCorrelative(adapter, activityId, correlativeId) {
+  const activity = adapter.getActivity(activityId);
+  if (!activity || activity.correlativeId === correlativeId) return null;
+  const before = Number(activity.correlativeId);
+  adapter.setActivityField(
+    activityId,
+    ACTIVITY_PROPERTY.CORRELATIVE_ID,
+    correlativeId
+  );
+  return { activityId, before: Number.isFinite(before) ? before : void 0 };
+}
+function pushChildrenInReverse(pending, children) {
+  for (let index = children.length - 1; index >= 0; index -= 1) {
+    const childId = children[index];
+    if (childId !== void 0) pending.push(childId);
+  }
+}
+
+// src/dispatch/handlers/persistence-rebase-rekey.ts
+var hasNoPersistedIdentity = (proplannerId) => proplannerId === null || proplannerId === void 0 || proplannerId === 0;
+var isUnpersisted = (activity) => hasNoPersistedIdentity(activity.proplannerId);
+function nextFreeLinkId(deps, taken) {
+  let candidate = deps.linkIdGen.next();
+  const isTaken = (linkId) => deps.adapter.getLink(linkId) !== null || deps.isLinkIdReserved(String(linkId)) || taken.has(String(linkId));
+  while (isTaken(candidate)) candidate = deps.linkIdGen.next();
+  return candidate;
+}
+function planLinkRekeys(remoteLinks, deps) {
+  const remoteLinkIds = /* @__PURE__ */ new Set();
+  for (const remote of remoteLinks) {
+    remoteLinkIds.add(String(remote.id));
+    deps.linkIdGen.bump(remote.id);
+  }
+  const taken = new Set(remoteLinkIds);
+  const rekeys = [];
+  for (const local of deps.adapter.getAllLinks()) {
+    const linkId = String(local.id);
+    if (!remoteLinkIds.has(linkId)) continue;
+    if (!hasNoPersistedIdentity(local.proplannerId)) continue;
+    const nextId = String(nextFreeLinkId(deps, taken));
+    taken.add(nextId);
+    rekeys.push({ from: linkId, to: nextId });
+  }
+  return rekeys;
+}
+function remoteCustomIdOwners(remoteActivities) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const remote of remoteActivities) {
+    if (remote.customId) owners.set(remote.customId, String(remote.id));
+  }
+  return owners;
+}
+function isLocalCustomIdEdit(local, deps) {
+  const saved = deps.persistenceCheckpoint.checkpointActivity(String(local.id));
+  return saved === null || saved.customId !== local.customId;
+}
+function planCustomIdRekeys(remoteActivities, deps) {
+  const owners = remoteCustomIdOwners(remoteActivities);
+  deps.customIdTracker.populateFromActivities(remoteActivities);
+  const rekeys = [];
+  for (const local of deps.adapter.getVisualOrderIds()) {
+    const activity = deps.adapter.getActivity(local);
+    if (!activity?.customId) continue;
+    const owner = owners.get(activity.customId);
+    if (owner === void 0) continue;
+    const isSameEntity = owner === String(activity.id) && !isUnpersisted(activity);
+    if (isSameEntity) continue;
+    if (!isLocalCustomIdEdit(activity, deps)) continue;
+    rekeys.push({
+      activityId: activity.id,
+      nextCustomId: deps.customIdTracker.generateCustomIdForRestoredChild(
+        activity.customId
+      )
+    });
+  }
+  return rekeys;
+}
+function nextFreeActivityId(deps, claimed) {
+  let candidate = deps.activityIdGen.next();
+  const isTaken = (activityId) => deps.adapter.activityExists(activityId) || deps.isActivityIdReserved(String(activityId)) || claimed.has(String(activityId));
+  while (isTaken(candidate)) candidate = deps.activityIdGen.next();
+  return candidate;
+}
+function planLocalRekeys(remote, deps) {
+  const remoteActivities = remote.activities;
+  const remoteIds = /* @__PURE__ */ new Set();
+  const remoteUniqueCorrelativeIds = /* @__PURE__ */ new Set();
+  for (const remote2 of remoteActivities) {
+    remoteIds.add(String(remote2.id));
+    remoteUniqueCorrelativeIds.add(String(remote2.uniqueCorrelativeId));
+    deps.activityIdGen.bump(remote2.id);
+    deps.uidGen.bump(remote2.uniqueCorrelativeId);
+  }
+  const claimed = /* @__PURE__ */ new Set();
+  const activities = [];
+  const uniqueCorrelativeIds = [];
+  for (const local of deps.adapter.getAllActivities()) {
+    if (!isUnpersisted(local)) continue;
+    const localId = String(local.id);
+    if (remoteIds.has(localId)) {
+      const nextId = nextFreeActivityId(deps, claimed);
+      claimed.add(String(nextId));
+      activities.push({
+        from: localId,
+        to: String(nextId),
+        parentId: deps.adapter.getParent(local.id)?.id ?? null,
+        childIds: [...deps.adapter.getChildren(local.id)],
+        outgoingLinkIds: [...deps.adapter.getOutgoingLinkIds(local.id)],
+        incomingLinkIds: [...deps.adapter.getIncomingLinkIds(local.id)]
+      });
+    }
+    if (remoteUniqueCorrelativeIds.has(String(local.uniqueCorrelativeId))) {
+      uniqueCorrelativeIds.push({
+        activityId: local.id,
+        nextUniqueCorrelativeId: deps.uidGen.next()
+      });
+    }
+  }
+  return {
+    activities,
+    links: planLinkRekeys(remote.links, deps),
+    uniqueCorrelativeIds,
+    customIds: planCustomIdRekeys(remoteActivities, deps)
+  };
+}
+function collectRekeyTouchedIds(plan) {
+  const touched = /* @__PURE__ */ new Set();
+  for (const rekey of plan.activities) {
+    touched.add(rekey.from);
+    touched.add(rekey.to);
+    if (rekey.parentId !== null) touched.add(String(rekey.parentId));
+    for (const childId of rekey.childIds) touched.add(String(childId));
+  }
+  for (const rekey of plan.uniqueCorrelativeIds) {
+    touched.add(String(rekey.activityId));
+  }
+  for (const rekey of plan.customIds) touched.add(String(rekey.activityId));
+  return touched;
+}
+function replaceId(ids, from, to) {
+  return ids.map((candidate) => String(candidate) === from ? to : candidate);
+}
+function moveActivityIdentity(rekey, adapter) {
+  const current = adapter.getActivity(rekey.from);
+  if (!current) return;
+  const relocated = structuredCloneActivity(current);
+  relocated.id = rekey.to;
+  const wasChecked = adapter.isChecked(rekey.from);
+  const wasVisible = adapter.isVisible(rekey.from);
+  const lastStartDate = adapter.getLastStartDate(rekey.from);
+  const promotionSnapshot = adapter.getPromotionSnapshot(rekey.from);
+  const progressFallback = adapter.getProgressFallback(rekey.from);
+  adapter.removeActivity(rekey.from);
+  adapter.addActivity(relocated);
+  if (wasChecked) adapter.setChecked(rekey.to, true);
+  if (!wasVisible) adapter.setVisible(rekey.to, false);
+  if (lastStartDate) adapter.setLastStartDate(rekey.to, lastStartDate);
+  if (promotionSnapshot) {
+    adapter.setPromotionSnapshot(rekey.to, promotionSnapshot);
+  }
+  if (progressFallback !== null) {
+    adapter.setProgressFallback(rekey.to, progressFallback);
+  }
+  for (const childId of rekey.childIds) {
+    adapter.setActivityFields(childId, { parentId: rekey.to });
+  }
+  for (const linkId of rekey.outgoingLinkIds) {
+    const link = adapter.getLink(linkId);
+    if (link) adapter.setLinkEndpoints(linkId, rekey.to, link.target);
+  }
+  for (const linkId of rekey.incomingLinkIds) {
+    const link = adapter.getLink(linkId);
+    if (link) adapter.setLinkEndpoints(linkId, link.source, rekey.to);
+  }
+  const parent = adapter.getParent(rekey.to);
+  if (!parent) return;
+  const parentTracksNewActivity = parent.newActivityIds.some(
+    (candidate) => String(candidate) === rekey.from
+  );
+  if (!parentTracksNewActivity) return;
+  adapter.setActivityFields(parent.id, {
+    newActivityIds: replaceId(parent.newActivityIds, rekey.from, rekey.to)
+  });
+}
+function moveLinkIdentities(rekeys, adapter) {
+  const before = /* @__PURE__ */ new Map();
+  const after = [];
+  for (const rekey of rekeys) {
+    const current = adapter.getLink(rekey.from);
+    if (!current) continue;
+    before.set(rekey.from, { ...current });
+    adapter.removeLink(rekey.from);
+    const relocated = { ...current, id: rekey.to };
+    adapter.addLink(relocated);
+    after.push(relocated);
+  }
+  return { before, after };
+}
+function applyLocalRekeys(plan, adapter) {
+  for (const rekey of plan.uniqueCorrelativeIds) {
+    adapter.setActivityField(
+      rekey.activityId,
+      ACTIVITY_PROPERTY.UNIQUE_CORRELATIVE_ID,
+      rekey.nextUniqueCorrelativeId
+    );
+  }
+  for (const rekey of plan.customIds) {
+    adapter.setActivityField(
+      rekey.activityId,
+      ACTIVITY_PROPERTY.CUSTOM_ID,
+      rekey.nextCustomId
+    );
+  }
+  for (const rekey of plan.activities) moveActivityIdentity(rekey, adapter);
+  return moveLinkIdentities(plan.links, adapter);
+}
+
+// src/dispatch/handlers/persistence-rebase.ts
+function pickDefaultCalendarId(calendars) {
+  for (const calendar of calendars.values()) {
+    if (calendar.is_default) return String(calendar.id);
+  }
+  return null;
+}
+function namesUnknownCalendar(action, calendars) {
+  return action.remote.activities.some(
+    (row2) => row2.calendarId != null && !calendars.has(String(row2.calendarId))
+  );
+}
+function normalizeRemote(action, deps) {
+  const { activities, activityIds } = normalizeActivities(
+    [...action.remote.activities],
+    {
+      knownCalendarIds: new Set(deps.calendars.keys()),
+      defaultCalendarId: pickDefaultCalendarId(deps.calendars),
+      hoursPerDay: deps.sector.hoursPerDay,
+      reporter: deps.reporter,
+      recordDiagnostic: noopLoadDiagnosticRecorder
+    }
+  );
+  const links = normalizeLinks([...action.remote.links], {
+    knownActivityIds: activityIds,
+    hoursPerDay: deps.sector.hoursPerDay,
+    reporter: deps.reporter,
+    recordDiagnostic: noopLoadDiagnosticRecorder
+  });
+  return { activities, links };
+}
+function hasPersistedRows(remote) {
+  return remote.activities.every(
+    (activity) => typeof activity.proplannerId === "number" && activity.proplannerId > 0
+  );
+}
+async function dispatchPersistenceRebase(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  if (namesUnknownCalendar(action, deps.calendars)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID };
+  }
+  const remote = normalizeRemote(action, deps);
+  if (!hasPersistedRows(remote)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID };
+  }
+  scheduler.invalidateAllCaches();
+  const localLinkOrder = unsavedLinkIdsInCreationOrder(adapter);
+  const rekeys = await rekeyCollidingLocalRows(remote, deps);
+  const plan = planPersistenceRebase({
+    remoteActivities: remote.activities,
+    remoteLinks: remote.links,
+    localActivities: adapter.getAllActivities(),
+    localLinks: adapter.getAllLinks(),
+    checkpoint: deps.persistenceCheckpoint
+  });
+  const siblingSources = captureSiblingOrders(
+    adapter.getAllActivities(),
+    remote.activities,
+    deps.persistenceCheckpoint
+  );
+  const removedActivityIds = new Set(plan.removeActivityIds);
+  const touchedIds = collectTouchedActivityIds(plan, adapter);
+  const beforeSnap = await snapshotBeforeRekeys(adapter, touchedIds, rekeys);
+  for (const activityId of rekeys.touchedIds) touchedIds.add(activityId);
+  const beforeLinks = captureLinksBefore(plan, removedActivityIds, adapter);
+  const viewStateChanges2 = captureDeletedViewState(adapter, removedActivityIds);
+  for (const linkId of beforeLinks.keys()) adapter.removeLink(linkId);
+  for (const activityId of removedActivityIds)
+    adapter.removeActivity(activityId);
+  for (const activity of plan.createActivities) {
+    adapter.addActivity(structuredCloneActivity(activity));
+    deps.uidGen.bump(activity.uniqueCorrelativeId);
+    deps.customIdTracker.populateFromActivities([activity]);
+  }
+  for (const merge of plan.updateActivities) {
+    adapter.setActivityFields(merge.activityId, merge.fields);
+  }
+  deriveLeafEndDates(plan, adapter);
+  const orphanConflicts = reparentOrphans(
+    adapter,
+    deps.persistenceCheckpoint,
+    touchedIds
+  );
+  demoteEmptiedParents(deps, touchedIds);
+  normalizeMergedParents(adapter, touchedIds);
+  recomputeTouchedRollups(adapter, touchedIds);
+  const linkChanges = [
+    ...rekeyedLinkChanges(rekeys.links),
+    ...applyLinkPlan(plan, beforeLinks, adapter)
+  ];
+  const droppedLinkConflicts = dropLinksWithoutEndpoints(adapter, linkChanges);
+  const cycleRepair = breakDependencyCycles(
+    adapter,
+    followRekeys(localLinkOrder, rekeys.plan.links),
+    linkChanges
+  );
+  const createdIds = new Set(
+    plan.createActivities.map((activity) => String(activity.id))
+  );
+  const insertedIds = /* @__PURE__ */ new Set([
+    ...createdIds,
+    ...rekeys.plan.activities.map((rekey) => rekey.to)
+  ]);
+  const siblingOrder = applySiblingOrder(adapter, siblingSources);
+  const correlativeShifts = [
+    ...siblingOrder.shifts,
+    ...recomputeCorrelativeIds(adapter)
+  ].filter((shift) => !insertedIds.has(shift.activityId));
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId,
+      runAutomaticP6Schedule: deps.runAutomaticP6Schedule
+    },
+    {
+      action,
+      autoscheduleFrom: AUTOSCHEDULE_SCOPE.ROOTS,
+      recomputeParentsFrom: withChildrenOfParents(touchedIds, adapter),
+      recomputeParentProgress: true,
+      now: deps.now,
+      options
+    }
+  );
+  alignParentAutoScheduling(adapter, touchedIds);
+  const changes = await assembleChangeSet(adapter, {
+    source: action,
+    beforeSnap,
+    touchedIds,
+    scheduledIds,
+    links: linkChanges,
+    hoursPerDay: sector.hoursPerDay,
+    correlativeShifts
+  });
+  const report = {
+    remoteChanges: plan.remoteChanges,
+    conflicts: [
+      ...plan.conflicts,
+      ...orphanConflicts,
+      ...siblingOrder.conflicts,
+      ...droppedLinkConflicts,
+      ...cycleRepair.conflicts
+    ],
+    createdActivityIds: [...createdIds],
+    removedActivityIds: [...removedActivityIds],
+    rekeyedActivities: rekeys.plan.activities.map(({ from, to }) => ({
+      from,
+      to
+    })),
+    rekeyedLinks: rekeys.plan.links,
+    createdLinkIds: plan.createLinks.map((link) => String(link.id)),
+    removedLinkIds: linkIdsGoneFromState(linkChanges, adapter)
+  };
+  return {
+    ok: true,
+    changes: viewStateChanges2.length > 0 ? { ...changes, viewState: viewStateChanges2 } : changes,
+    rebase: report,
+    __beforeSnap: beforeSnap,
+    __beforeLinks: new Map([
+      ...rekeys.links.before,
+      ...beforeLinks,
+      ...cycleRepair.removed
+    ]),
+    __rebaseCheckpoint: { activities: remote.activities, links: remote.links }
+  };
+}
+function linkIdsGoneFromState(linkChanges, adapter) {
+  return linkChanges.filter((change) => change.kind === ENTITY_CHANGE_KIND.DELETED).map((change) => String(change.id)).filter((linkId) => !adapter.getLink(linkId));
+}
+async function rekeyCollidingLocalRows(remote, deps) {
+  const plan = planLocalRekeys(remote, deps);
+  const touchedIds = collectRekeyTouchedIds(plan);
+  const beforeSnap = await snapshotActivities(deps.adapter, touchedIds);
+  const links = applyLocalRekeys(plan, deps.adapter);
+  return { plan, touchedIds, beforeSnap, links };
+}
+function rekeyedLinkChanges(links) {
+  const changes = [
+    ...buildLinkDeletions(new Map(links.before))
+  ];
+  for (const after of links.after) {
+    changes.push({
+      id: String(after.id),
+      kind: ENTITY_CHANGE_KIND.CREATED,
+      fields: {
+        source: { before: void 0, after: String(after.source) },
+        target: { before: void 0, after: String(after.target) },
+        type: { before: void 0, after: after.type },
+        lag: { before: void 0, after: Number(after.lag) }
+      },
+      after: snapshotToLink(after)
+    });
+  }
+  return changes;
+}
+async function snapshotBeforeRekeys(adapter, touchedIds, rekeys) {
+  const touchedOutsideRekey = new Set(
+    [...touchedIds].filter((activityId) => !rekeys.touchedIds.has(activityId))
+  );
+  return new Map([
+    ...await snapshotActivities(adapter, touchedOutsideRekey),
+    ...rekeys.beforeSnap
+  ]);
+}
+function deriveLeafEndDates(plan, adapter) {
+  for (const merge of plan.updateActivities) {
+    const activity = adapter.getActivity(merge.activityId);
+    if (!activity || adapter.hasChildren(activity.id)) continue;
+    adapter.setActivityField(
+      activity.id,
+      ACTIVITY_PROPERTY.END_DATE,
+      adapter.calculateEndDate({
+        startDate: activity.startDate,
+        durationHours: activity.durationHours,
+        task: activity
+      })
+    );
+  }
+}
+function unsavedLinkIdsInCreationOrder(adapter) {
+  return adapter.getAllLinks().filter((link) => {
+    const proplannerId = link.proplannerId;
+    return proplannerId === null || proplannerId === void 0 || proplannerId === 0;
+  }).map((link) => String(link.id)).sort((left, right) => Number(left) - Number(right));
+}
+function followRekeys(linkIds, rekeys) {
+  const renamed = new Map(rekeys.map(({ from, to }) => [from, to]));
+  return linkIds.map((linkId) => renamed.get(linkId) ?? linkId);
+}
+function alignParentAutoScheduling(adapter, touchedIds) {
+  for (const activityId of touchedIds) {
+    if (!adapter.hasChildren(activityId)) continue;
+    const activity = adapter.getActivity(activityId);
+    if (!activity) continue;
+    const autoScheduling = isAutoSchedulingEnabledForProgress(
+      activity.progress
+    );
+    if (activity.autoScheduling === autoScheduling) continue;
+    adapter.setActivityField(
+      activityId,
+      ACTIVITY_PROPERTY.AUTO_SCHEDULING,
+      autoScheduling
+    );
+  }
+}
+function normalizeMergedParents(adapter, touchedIds) {
+  for (const activityId of touchedIds) {
+    if (!adapter.hasChildren(activityId)) continue;
+    const activity = adapter.getActivity(activityId);
+    if (!activity) continue;
+    if (activity.type !== ACTIVITY_TYPE.PROJECT) {
+      adapter.setActivityField(
+        activityId,
+        ACTIVITY_PROPERTY.TYPE,
+        ACTIVITY_TYPE.PROJECT
+      );
+    }
+    if (activity.customId) {
+      adapter.setActivityField(activityId, ACTIVITY_PROPERTY.CUSTOM_ID, null);
+    }
+  }
+}
+function demoteEmptiedParents(deps, touchedIds) {
+  const { adapter } = deps;
+  for (const activityId of touchedIds) {
+    const activity = adapter.getActivity(activityId);
+    if (!activity || activity.type !== ACTIVITY_TYPE.PROJECT) continue;
+    if (isRootParent(activity.parentId) || adapter.hasChildren(activityId)) {
+      continue;
+    }
+    const demotion = buildParentDemotionMutations({
+      parent: activity,
+      remainingChildIds: [],
+      defaultDurationHours: deps.sector.hoursPerDay,
+      promotionSnapshot: adapter.getPromotionSnapshot(activityId),
+      computeEndDate: (startDate, durationHours) => adapter.calculateEndDate({ startDate, durationHours, task: activity }),
+      dataDateCapability: deps.dataDateCapability,
+      hasCompleteSchedulingState: deps.hasCompleteSchedulingState
+    });
+    if (!demotion) continue;
+    adapter.setActivityFields(activityId, demotion.fields);
+    const previousSiblingId = findPrevSiblingHelper(activityId, adapter);
+    const previousCustomId = previousSiblingId ? adapter.getActivity(previousSiblingId)?.customId : null;
+    adapter.setActivityField(
+      activityId,
+      ACTIVITY_PROPERTY.CUSTOM_ID,
+      deps.customIdTracker.generateCustomIdForRestoredChild(
+        previousCustomId || null
+      )
+    );
+  }
+}
+function recomputeTouchedRollups(adapter, touchedIds) {
+  const parentIds = /* @__PURE__ */ new Set();
+  for (const activityId of touchedIds) {
+    const activity = adapter.getActivity(activityId);
+    if (!activity) continue;
+    if (adapter.hasChildren(activityId)) parentIds.add(activityId);
+    if (!isRootParent(activity.parentId)) {
+      parentIds.add(String(activity.parentId));
+    }
+  }
+  for (const parentId of parentIds) {
+    recomputeRollupCascadesForParent(parentId, adapter);
+  }
+}
+function withChildrenOfParents(activityIds, adapter) {
+  const seeds = new Set(activityIds);
+  for (const activityId of activityIds) {
+    for (const childId of adapter.getChildren(activityId)) {
+      seeds.add(String(childId));
+    }
+  }
+  return seeds;
+}
+function collectTouchedActivityIds(plan, adapter) {
+  const touched = /* @__PURE__ */ new Set();
+  const touchParent = (parentId) => {
+    if (parentId === null || parentId === void 0) return;
+    if (isRootParent(parentId)) return;
+    touched.add(String(parentId));
+  };
+  for (const activityId of plan.removeActivityIds) {
+    touched.add(activityId);
+    touchParent(adapter.getActivity(activityId)?.parentId);
+  }
+  for (const activity of plan.createActivities) {
+    touched.add(String(activity.id));
+    touchParent(activity.parentId);
+  }
+  for (const merge of plan.updateActivities) {
+    touched.add(merge.activityId);
+    touchParent(adapter.getActivity(merge.activityId)?.parentId);
+    if (merge.fields.parentId !== void 0) touchParent(merge.fields.parentId);
+  }
+  return touched;
+}
+function captureLinksBefore(plan, removedActivityIds, adapter) {
+  const before = /* @__PURE__ */ new Map();
+  const incident = collectIncidentLinkIds(removedActivityIds, adapter);
+  for (const linkId of [...plan.removeLinkIds, ...incident]) {
+    const link = adapter.getLink(linkId);
+    if (link) before.set(String(linkId), { ...link });
+  }
+  return before;
+}
+function nearestSurvivingAncestor(missingParentId, adapter, checkpoint) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = missingParentId;
+  while (current !== null && !visited.has(current)) {
+    if (adapter.activityExists(current)) return current;
+    visited.add(current);
+    const saved = checkpoint.checkpointActivity(current);
+    if (!saved || isRootParent(saved.parentId)) return null;
+    current = String(saved.parentId);
+  }
+  return null;
+}
+function reparentOrphans(adapter, checkpoint, touchedIds) {
+  const conflicts = [];
+  for (const activity of adapter.getAllActivities()) {
+    if (isRootParent(activity.parentId)) continue;
+    if (adapter.activityExists(String(activity.parentId))) continue;
+    const previousParentId = String(activity.parentId);
+    const adoptiveParentId = nearestSurvivingAncestor(
+      previousParentId,
+      adapter,
+      checkpoint
+    );
+    adapter.setActivityField(
+      activity.id,
+      ACTIVITY_PROPERTY.PARENT,
+      adoptiveParentId
+    );
+    touchedIds.add(String(activity.id));
+    if (adoptiveParentId !== null) touchedIds.add(adoptiveParentId);
+    conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.ACTIVITY,
+      id: String(activity.id),
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.PARENT_REMOVED,
+      field: ACTIVITY_PROPERTY.PARENT,
+      mine: previousParentId,
+      theirs: adoptiveParentId ?? ROOT_PARENT_ID
+    });
+  }
+  return conflicts;
+}
+function applyLinkPlan(plan, beforeLinks, adapter) {
+  const changes = [
+    ...buildLinkDeletions(new Map(beforeLinks))
+  ];
+  for (const link of plan.createLinks) {
+    if (adapter.getLink(link.id)) continue;
+    adapter.addLink({ ...link, freeSlackHours: null, isCritical: false });
+    const after = adapter.getLink(link.id);
+    if (!after) continue;
+    changes.push({
+      id: String(link.id),
+      kind: ENTITY_CHANGE_KIND.CREATED,
+      fields: {
+        source: { before: void 0, after: String(after.source) },
+        target: { before: void 0, after: String(after.target) },
+        type: { before: void 0, after: after.type },
+        lag: { before: void 0, after: Number(after.lag) }
+      },
+      after: snapshotToLink(after)
+    });
+  }
+  for (const merge of plan.updateLinks) {
+    const before = adapter.getLink(merge.linkId);
+    if (!before) continue;
+    const beforeView = snapshotToLink(before);
+    const fields = {};
+    for (const [field, value] of Object.entries(merge.fields)) {
+      adapter.setLinkFieldDynamic(merge.linkId, field, value);
+      fields[field] = { before: Reflect.get(beforeView, field), after: value };
+    }
+    const after = adapter.getLink(merge.linkId);
+    if (!after) continue;
+    changes.push({
+      id: String(merge.linkId),
+      kind: ENTITY_CHANGE_KIND.UPDATED,
+      fields,
+      after: snapshotToLink(after)
+    });
+  }
+  return changes;
+}
+function dropLinksWithoutEndpoints(adapter, changes) {
+  const conflicts = [];
+  for (const link of adapter.getAllLinks()) {
+    const missingEndpoint = [link.source, link.target].find(
+      (activityId) => !adapter.activityExists(String(activityId))
+    );
+    if (missingEndpoint === void 0) continue;
+    const linkId = String(link.id);
+    const before = { ...link };
+    const sourceIsMissing = String(link.source) === String(missingEndpoint);
+    adapter.removeLink(linkId);
+    changes.push(...buildLinkDeletions(/* @__PURE__ */ new Map([[linkId, before]])));
+    conflicts.push({
+      entity: PERSISTENCE_REBASE_ENTITY.LINK,
+      id: linkId,
+      kind: PERSISTENCE_REBASE_CONFLICT_KIND.DELETED_REMOTELY,
+      field: sourceIsMissing ? LINK_PROPERTY.SOURCE : LINK_PROPERTY.TARGET,
+      mine: snapshotToLink(before),
+      theirs: null
+    });
+  }
+  return conflicts;
+}
+
+// src/baselines/apply-baseline-points.ts
+function applyBaselinePoints(adapter, points, reporter, recordDiagnostic = noopLoadDiagnosticRecorder) {
+  const idByProplanner = /* @__PURE__ */ new Map();
+  adapter.forEachActivity((a, id) => {
+    const pid = a.proplannerId;
+    if (typeof pid === "number") idByProplanner.set(pid, id);
+  });
+  const grouped = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const activityId = p.activityId;
+    if (typeof activityId !== "number") {
+      recordDiagnostic(
+        LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
+        String(activityId ?? "unknown")
+      );
+      continue;
+    }
+    const coreId = idByProplanner.get(activityId);
+    if (coreId === void 0) {
+      recordDiagnostic(
+        LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
+        String(activityId)
+      );
+      continue;
+    }
+    const arr = grouped.get(coreId);
+    if (arr) arr.push(p);
+    else grouped.set(coreId, [p]);
+  }
+  const changed2 = [];
+  for (const [coreId, group] of grouped) {
+    const isMilestone = adapter.getActivity(coreId)?.type === ACTIVITY_TYPE.MILESTONE;
+    adapter.setActivityField(
+      coreId,
+      "baselinePoints",
+      group.map(
+        (point) => normalizeBaselinePoint(
+          point,
+          reporter,
+          {
+            record: recordDiagnostic,
+            sampleId: coreId
+          },
+          isMilestone
+        )
+      ).filter((point) => point !== null)
+    );
+    changed2.push(coreId);
+  }
+  adapter.forEachActivity((a, id) => {
+    if (grouped.has(id)) return;
+    const existing = a.baselinePoints;
+    if (Array.isArray(existing) && existing.length > 0) {
+      adapter.setActivityField(id, "baselinePoints", []);
+      changed2.push(id);
+    }
+  });
+  return changed2;
+}
+
+// src/baselines/baseline-snapshot.ts
+function buildBaselineSnapshot(activity) {
+  const active = getActiveBaseline(activity);
+  if (!active) return null;
+  return {
+    startDate: active.startDate,
+    endDate: active.endDate,
+    durationDays: active.durationDays,
+    cost: active.cost,
+    workHours: active.workHours
+  };
+}
+function emitBaselineSnapshotColumns(state) {
+  const changed2 = [];
+  state.forEachActivity((activity, id) => {
+    const snapshot = buildBaselineSnapshot(activity);
+    if (!snapshot) {
+      if (activity.baselineSnapshot !== null) {
+        state.setActivityField(id, "baselineSnapshot", null);
+        changed2.push(id);
+      }
+      return;
+    }
+    state.setActivityField(id, "baselineSnapshot", snapshot);
+    changed2.push(id);
+  });
+  return changed2;
+}
+
+// src/baselines/apply-baseline-overlay.ts
+function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarId = null, recordDiagnostic = noopLoadDiagnosticRecorder) {
+  const changed2 = /* @__PURE__ */ new Set();
+  for (const id of applyBaselinePoints(
+    state,
+    points,
+    reporter,
+    recordDiagnostic
+  )) {
+    changed2.add(id);
+  }
+  if (now) {
+    for (const id of runExpectedProgressBase(state, now, defaultBaseCalendarId))
+      changed2.add(id);
+  }
+  for (const id of emitBaselineSnapshotColumns(state)) changed2.add(id);
+  for (const id of emitRealCost(state)) changed2.add(id);
+  return [...changed2];
+}
+
+// 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, basisById);
+    }
+  });
+}
+
+// src/dispatch/shared/baseline-weighted-fields.ts
+function recomputeBaselineWeightedFields(deps, criterion) {
+  recomputeAllPonderators(criterion, deps.adapter);
+  recomputeAllProgressRollup(deps.adapter, criterion);
+  if (deps.now) {
+    runExpectedProgressBase(
+      deps.adapter,
+      deps.now,
+      deps.defaultBaseCalendarId ?? null
+    );
+    applyExpectedProgressLive(deps.adapter, deps.now);
+  }
+  emitRealCost(deps.adapter);
+  if (deps.now) applyStatusPass(deps.adapter, deps.sector.statusCriteria);
+}
+
+// src/dispatch/handlers/baseline-apply.ts
+function activeBaselineSignature(deps) {
+  return JSON.stringify(
+    deps.adapter.getAllIds().map((id) => {
+      const point = deps.adapter.getActivity(id)?.baselinePoints.find((candidate) => candidate.isActiveVersion);
+      return point ? [
+        String(id),
+        point.versionId,
+        point.startDate?.getTime() ?? null,
+        point.endDate?.getTime() ?? null,
+        point.durationDays,
+        point.cost,
+        point.workHours,
+        point.baseCalendarId,
+        point.hoursPerDay,
+        point.hoursPerWeek
+      ] : [String(id), null];
+    })
+  );
+}
+async function dispatchBaselineApply(action, deps) {
+  const beforeSnap = await snapshotActivities(
+    deps.adapter,
+    new Set(deps.adapter.getAllIds())
+  );
+  const activeBaselineBefore = activeBaselineSignature(deps);
+  const changedIds = applyBaselineOverlay(
+    deps.adapter,
+    action.points,
+    deps.now,
+    deps.reporter,
+    deps.defaultBaseCalendarId ?? null,
+    void 0
+  );
+  applyBaselineVariancePass(deps.adapter, deps.sector.hoursPerDay);
+  applyRoleBaselineVariancePass(deps.adapter, deps.sector.hoursPerDay);
+  if (activeBaselineSignature(deps) !== activeBaselineBefore) {
+    recomputeBaselineWeightedFields(
+      deps,
+      deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
+    );
+  }
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: changedIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/ponderator-criterion-set.ts
+function isValidCriterion(value) {
+  return Object.values(ACTIVITY_PONDERATOR_CRITERION).includes(
+    value
+  );
+}
+async function dispatchPonderatorCriterionSet(action, deps) {
+  if (!isValidCriterion(action.criterion)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  const allIds = new Set(deps.adapter.getAllIds());
+  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
+  recomputeBaselineWeightedFields(deps, action.criterion);
+  deps.sector.activityCreter = action.criterion;
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: allIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/status-criteria-set.ts
+async function dispatchStatusCriteriaSet(action, deps) {
+  const resolved = resolveStatusCriteria(action.criteria);
+  const allIds = new Set(deps.adapter.getAllIds());
+  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
+  const changedIds = applyStatusPass(deps.adapter, resolved);
+  deps.sector.statusCriteria = resolved;
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: changedIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/calendar-reconcile.ts
+async function dispatchCalendarReconcile(action, options, deps) {
+  const beforeSnap = /* @__PURE__ */ new Map();
+  const touchedIds = /* @__PURE__ */ new Set();
+  for (const activity of deps.adapter.getAllActivities()) {
+    if (!shouldReconcile(activity, deps)) continue;
+    const calendar = deps.ctx.calendars.getCalendar(activity.calendarId);
+    if (!calendar) continue;
+    const startReference = calendar.isWorkTime(
+      activity.startDate,
+      CALENDAR_UNIT.HOUR
+    ) ? startOfUtcDay4(activity.startDate) : activity.startDate;
+    const startDate = calendar.getClosestWorkTime({
+      date: startReference,
+      direction: WORK_TIME_DIRECTION.FUTURE,
+      unit: CALENDAR_UNIT.HOUR
+    });
+    const endDate = calendar.calculateEndDate(
+      startDate,
+      activity.durationHours
+    );
+    if (sameInstant(startDate, activity.startDate) && sameInstant(endDate, activity.endDate)) {
+      continue;
+    }
+    const activityId = String(activity.id);
+    beforeSnap.set(activityId, structuredCloneActivity(activity));
+    touchedIds.add(activityId);
+    deps.adapter.setActivityFields(activityId, { startDate, endDate });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId,
+      runAutomaticP6Schedule: deps.runAutomaticP6Schedule
+    },
+    {
+      action,
+      autoscheduleFrom: AUTOSCHEDULE_SCOPE.ROOTS,
+      recomputeParentsFrom: touchedIds,
       now: deps.now,
       options
     }
@@ -19869,6 +21792,9 @@ async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
     return dispatchPersistenceAcknowledge(action, deps);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_REBASE) {
+    return dispatchPersistenceRebase(action, options, deps);
+  }
   if (action.kind === DISPATCH_ACTION_KIND.BASELINE_APPLY) {
     return dispatchBaselineApply(action, deps);
   }
@@ -19975,18 +21901,63 @@ function selectionDeps(deps) {
 }
 
 // src/columns/shared/field-types.ts
-var DATE_FIELDS = /* @__PURE__ */ new Set([
+var DATE_FIELDS2 = /* @__PURE__ */ new Set([
   "startDate",
   "endDate",
   "constraintDate"
 ]);
 function coerceActivityFieldValue(field, value) {
-  if (DATE_FIELDS.has(field) && typeof value === "string") {
+  if (DATE_FIELDS2.has(field) && typeof value === "string") {
     return new Date(value);
   }
   return value;
 }
 
+// src/calendar/closest-past-work-time.ts
+var MS_PER_MINUTE = 60 * 1e3;
+var MS_PER_DAY = 24 * 60 * MS_PER_MINUTE;
+var MINUTES_PER_HOUR = 60;
+var MAX_LOOKBACK_DAYS = 3660;
+var LAST_MINUTE_OF_DAY_MS = MS_PER_DAY - MS_PER_MINUTE;
+var WINDOW_SEPARATOR = "-";
+var TIME_SEPARATOR = ":";
+function closestPastWorkTime(calendar, date2, unit) {
+  if (calendar.isWorkTime({ date: date2, unit })) return date2;
+  const dayStart = utcDayStart(date2);
+  if (unit !== CALENDAR_UNIT.DAY) {
+    const elapsed = date2.getTime() - dayStart;
+    const sameDayEnd = latestWindowEnd(calendar, dayStart, elapsed);
+    if (sameDayEnd !== null) return new Date(dayStart + sameDayEnd);
+  }
+  const searchesFromWorkingDay = calendar.getWorkHours(date2).length > 0;
+  for (let back = 1; back <= MAX_LOOKBACK_DAYS; back++) {
+    const candidate = dayStart - back * MS_PER_DAY;
+    const lastEnd = latestWindowEnd(calendar, candidate, MS_PER_DAY);
+    if (lastEnd === null) continue;
+    if (unit !== CALENDAR_UNIT.DAY) {
+      const end = searchesFromWorkingDay ? Math.min(lastEnd, LAST_MINUTE_OF_DAY_MS) : lastEnd;
+      return new Date(candidate + end);
+    }
+    return new Date(candidate + MS_PER_DAY);
+  }
+  throw new Error(
+    `No working day found within ${MAX_LOOKBACK_DAYS} days before ${date2.toISOString()}`
+  );
+}
+function utcDayStart(date2) {
+  return Date.UTC(date2.getUTCFullYear(), date2.getUTCMonth(), date2.getUTCDate());
+}
+function latestWindowEnd(calendar, dayStart, atOrBefore) {
+  const ends = calendar.getWorkHours(new Date(dayStart)).map(windowEndMs).filter((end) => end <= atOrBefore);
+  return ends.length ? Math.max(...ends) : null;
+}
+function windowEndMs(window2) {
+  const end = window2.split(WINDOW_SEPARATOR)[1] ?? "";
+  const [hours = "0", minutes = "0"] = end.split(TIME_SEPARATOR);
+  const endMs = (Number(hours) * MINUTES_PER_HOUR + Number(minutes)) * MS_PER_MINUTE;
+  return endMs;
+}
+
 // src/calendar/adapter.ts
 var WORK_CALENDAR_UNIT = { MINUTE: "minute" };
 function createWorkCalendarAdapter(instance, options = {}) {
@@ -20002,6 +21973,9 @@ function createWorkCalendarAdapter(instance, options = {}) {
 function wrapWorkCalendar(calendar, defaultUnit) {
   return {
     getClosestWorkTime(query) {
+      if (query.direction === WORK_TIME_DIRECTION.PAST) {
+        return closestPastWorkTime(calendar, query.date, query.unit);
+      }
       return calendar.getClosestWorkTime({
         date: query.date,
         dir: query.direction,
@@ -22898,7 +24872,7 @@ var CalendarCalculator = class {
     this.reader = setup.reader;
   }
   resolveCalendar(task) {
-    const calendarId = resolveCalendarId(task);
+    const calendarId = resolveCalendarId2(task);
     return this.reader.getCalendar(calendarId ?? DEFAULT_CALENDAR_ID);
   }
   getClosestWorkTime(params) {
@@ -22955,14 +24929,14 @@ function memoize(cache, key, compute) {
   return result;
 }
 var DEFAULT_CALENDAR_KEY = "__default__";
-function resolveCalendarId(task) {
+function resolveCalendarId2(task) {
   if (!task) return null;
   const calendarId = task.calendarId;
   if (calendarId == null) return null;
   return String(calendarId);
 }
 function calendarKey(task) {
-  return resolveCalendarId(task) ?? DEFAULT_CALENDAR_KEY;
+  return resolveCalendarId2(task) ?? DEFAULT_CALENDAR_KEY;
 }
 
 // src/internal/state/hierarchy-index.ts
@@ -24247,43 +26221,6 @@ function computeProjectWorkHours(calendars) {
   return { startHour: earliestTime(starts), endHour: latestTime(ends) };
 }
 
-// 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 EXCEPTION_EVERY_TYPE = {
-  DAILY: "DAILY",
-  WEEKLY: "WEEKLY",
-  MONTHLY: "MONTHLY",
-  YEARLY: "YEARLY"
-};
-var MONTHS_PER_YEAR = 12;
-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;
@@ -24298,10 +26235,10 @@ function normalizeCalendars(schedulingCalendars, sectorCalendars, rawBaseCalenda
     calendars,
     baseCalendars,
     knownCalendarIds: new Set(calendars.map((calendar) => calendar.id)),
-    defaultCalendarId: pickDefaultCalendarId(calendars)
+    defaultCalendarId: pickDefaultCalendarId2(calendars)
   };
 }
-function pickDefaultCalendarId(calendars) {
+function pickDefaultCalendarId2(calendars) {
   let firstCalendarId = null;
   for (const calendar of calendars) {
     firstCalendarId ??= calendar.id;
@@ -24366,14 +26303,24 @@ function parseExceptionDays(exceptions, range) {
 }
 function expandRangeToUtcKeys(from, to, range, everyType) {
   const fromTs = parseExceptionDate(from);
-  const toTs = parseExceptionDate(to);
-  if (fromTs === null || toTs === null) return [];
+  const toDay = parseExceptionDate(to);
+  if (fromTs === null || toDay === null) return [];
+  const toTs = endsAtMidnightAfterStart(from, to, fromTs, toDay) ? toDay - DAY_MS : toDay;
   if (range && (toTs < range.start || fromTs > range.end)) return [];
   const first = range ? Math.max(fromTs, range.start) : fromTs;
   const last = range ? Math.min(toTs, range.end) : toTs;
   const timestamps = steppedTimestamps(fromTs, first, last, everyType);
   return timestamps.map(String);
 }
+function endsAtMidnightAfterStart(from, to, fromDay, toDay) {
+  if (toDay <= fromDay) return false;
+  return isMidnight(to) && !isMidnight(from);
+}
+function isMidnight(raw) {
+  if (typeof raw !== "string") return false;
+  const match = EXCEPTION_TIME_FORMAT_REGEX.exec(raw.trim());
+  return match !== null && Number(match[1]) === 0 && Number(match[2]) === 0;
+}
 function steppedTimestamps(anchor, first, last, everyType) {
   switch (everyType) {
     case EXCEPTION_EVERY_TYPE.DAILY:
@@ -24548,7 +26495,7 @@ function buildPipelineContext(adapter, options) {
   return {
     calendars: adapter.calendarReader,
     hasCalendar: (calendarId) => options.calendars.has(calendarId),
-    getDefaultCalendarId: () => pickDefaultCalendarId(options.calendars.values()),
+    getDefaultCalendarId: () => pickDefaultCalendarId2(options.calendars.values()),
     hierarchy: createStateBackedHierarchyReader(adapter),
     activityReader: createStateBackedActivityReader(adapter),
     dateFormat: options.dateFormat ?? "YYYY-MM-DD",
@@ -24665,7 +26612,8 @@ function mergeCoalesced(top, next) {
 var DISPATCH_HISTORY_POLICY = {
   RECORD: "record",
   SKIP: "skip",
-  CHECKPOINT_ON_SUCCESS: "checkpoint-on-success"
+  CHECKPOINT_ON_SUCCESS: "checkpoint-on-success",
+  REBASE_ON_SUCCESS: "rebase-on-success"
 };
 var CHANGE_SET_SIDE = {
   BEFORE: "before",
@@ -24675,6 +26623,9 @@ function getDispatchHistoryPolicy(action) {
   if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
     return DISPATCH_HISTORY_POLICY.CHECKPOINT_ON_SUCCESS;
   }
+  if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_REBASE) {
+    return DISPATCH_HISTORY_POLICY.REBASE_ON_SUCCESS;
+  }
   if (action.kind === DISPATCH_ACTION_KIND.SIR_SYNC || action.kind === DISPATCH_ACTION_KIND.CALENDAR_RECONCILE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC || action.kind === DISPATCH_ACTION_KIND.BASELINE_APPLY || action.kind === DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET || action.kind === DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_IMPORT || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_COPY || action.kind === DISPATCH_ACTION_KIND.SELECTION_TOGGLE || action.kind === DISPATCH_ACTION_KIND.SELECTION_REPLACE || action.kind === DISPATCH_ACTION_KIND.VISIBILITY_SET || action.kind === DISPATCH_ACTION_KIND.FILTER_SET || action.kind === DISPATCH_ACTION_KIND.SORT_SET || action.kind === DISPATCH_ACTION_KIND.VIEW_ATTRIBUTES_SET || action.kind === DISPATCH_ACTION_KIND.GROUP_SET || action.kind === DISPATCH_ACTION_KIND.WBS_DEPTH_SET) {
     return DISPATCH_HISTORY_POLICY.SKIP;
   }
@@ -25090,7 +27041,7 @@ function collectResequencedParents(changes, parentOf) {
     if (change.kind === ENTITY_CHANGE_KIND.DELETED) {
       const deletedFields = change.fields;
       if (deletedFields && "parentId" in deletedFields) {
-        touched.add(parentKeyOf2(deletedFields.parentId?.before));
+        touched.add(parentKeyOf4(deletedFields.parentId?.before));
       }
       continue;
     }
@@ -25102,12 +27053,12 @@ function collectResequencedParents(changes, parentOf) {
     if (!movedPositionally) continue;
     addParentOf(activityId);
     if ("parentId" in fields) {
-      touched.add(parentKeyOf2(fields.parentId?.before));
+      touched.add(parentKeyOf4(fields.parentId?.before));
     }
   }
   return touched;
 }
-function parentKeyOf2(parentId) {
+function parentKeyOf4(parentId) {
   if (parentId === null || parentId === void 0) return ROOT_PARENT_ID;
   return String(parentId);
 }
@@ -25151,154 +27102,6 @@ function buildStateSnapshot(activities, links, calendars, baseCalendars = []) {
   };
 }
 
-// src/boundary/save/field-policy.ts
-var SAVE_FIELD_POLICY = {
-  TRACKED: "tracked",
-  IGNORED: "ignored"
-};
-
-// src/boundary/save/activity-changes.ts
-var ACTIVITY_SAVE_FIELD_POLICY = {
-  id: SAVE_FIELD_POLICY.IGNORED,
-  proplannerId: SAVE_FIELD_POLICY.IGNORED,
-  parentId: SAVE_FIELD_POLICY.TRACKED,
-  name: SAVE_FIELD_POLICY.TRACKED,
-  description: SAVE_FIELD_POLICY.TRACKED,
-  type: SAVE_FIELD_POLICY.TRACKED,
-  startDate: SAVE_FIELD_POLICY.TRACKED,
-  endDate: SAVE_FIELD_POLICY.TRACKED,
-  durationHours: SAVE_FIELD_POLICY.TRACKED,
-  constraintType: SAVE_FIELD_POLICY.TRACKED,
-  constraintDate: SAVE_FIELD_POLICY.TRACKED,
-  autoScheduling: SAVE_FIELD_POLICY.TRACKED,
-  calendarId: SAVE_FIELD_POLICY.TRACKED,
-  assignedDefaultCalendar: SAVE_FIELD_POLICY.IGNORED,
-  dateOrigin: SAVE_FIELD_POLICY.TRACKED,
-  progress: SAVE_FIELD_POLICY.TRACKED,
-  cost: SAVE_FIELD_POLICY.TRACKED,
-  usedCost: SAVE_FIELD_POLICY.TRACKED,
-  realCost: SAVE_FIELD_POLICY.TRACKED,
-  workHours: SAVE_FIELD_POLICY.TRACKED,
-  realWorkHours: SAVE_FIELD_POLICY.TRACKED,
-  ponderator: SAVE_FIELD_POLICY.TRACKED,
-  hasCustomPonderator: SAVE_FIELD_POLICY.TRACKED,
-  correlativeId: SAVE_FIELD_POLICY.TRACKED,
-  uniqueCorrelativeId: SAVE_FIELD_POLICY.TRACKED,
-  customId: SAVE_FIELD_POLICY.TRACKED,
-  subcontractId: SAVE_FIELD_POLICY.TRACKED,
-  isLookahead: SAVE_FIELD_POLICY.TRACKED,
-  hasLookaheadTasks: SAVE_FIELD_POLICY.IGNORED,
-  newActivityIds: SAVE_FIELD_POLICY.TRACKED,
-  hasNewActivities: SAVE_FIELD_POLICY.TRACKED,
-  isNewActivity: SAVE_FIELD_POLICY.IGNORED,
-  pendingRequestIds: SAVE_FIELD_POLICY.IGNORED,
-  responsableIds: SAVE_FIELD_POLICY.TRACKED,
-  tagIds: SAVE_FIELD_POLICY.TRACKED,
-  baselinePoints: SAVE_FIELD_POLICY.IGNORED,
-  baselineSnapshot: SAVE_FIELD_POLICY.IGNORED,
-  recursiveDurationHours: SAVE_FIELD_POLICY.IGNORED,
-  isCritical: SAVE_FIELD_POLICY.IGNORED,
-  freeSlackHours: SAVE_FIELD_POLICY.IGNORED,
-  calendarDuration: SAVE_FIELD_POLICY.IGNORED,
-  baselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
-  projectBaselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
-  primaryBaselineVarianceDays: SAVE_FIELD_POLICY.IGNORED,
-  expectedProgress: SAVE_FIELD_POLICY.IGNORED,
-  expectedProgressBaseline: SAVE_FIELD_POLICY.IGNORED,
-  status: SAVE_FIELD_POLICY.IGNORED,
-  criticalPath: SAVE_FIELD_POLICY.IGNORED,
-  p6: SAVE_FIELD_POLICY.IGNORED
-};
-var PERSISTABLE_ACTIVITY_FIELDS = Object.keys(ACTIVITY_SAVE_FIELD_POLICY).filter((field) => {
-  return ACTIVITY_SAVE_FIELD_POLICY[field] === SAVE_FIELD_POLICY.TRACKED;
-});
-var DATE_FIELDS2 = /* @__PURE__ */ new Set([
-  "startDate",
-  "endDate",
-  "constraintDate",
-  "dateOrigin"
-]);
-var ID_ARRAY_FIELDS = /* @__PURE__ */ new Set([
-  "newActivityIds",
-  "responsableIds",
-  "tagIds"
-]);
-function projectPersistableActivity(activity) {
-  const entries = PERSISTABLE_ACTIVITY_FIELDS.map(
-    (field) => [field, snapshotFieldValue(field, activity[field])]
-  );
-  return Object.fromEntries(entries);
-}
-function snapshotFieldValue(field, value) {
-  if (DATE_FIELDS2.has(field)) {
-    return value instanceof Date ? new Date(value) : null;
-  }
-  if (ID_ARRAY_FIELDS.has(field)) {
-    return Array.isArray(value) ? [...value] : [];
-  }
-  return value;
-}
-function activityChangedSince(current, saved) {
-  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);
-  if (ID_ARRAY_FIELDS.has(field))
-    return idArrayEquals(currentValue, savedValue);
-  return (currentValue ?? null) === (savedValue ?? null);
-}
-function dateEquals(current, saved) {
-  const currentTime = current instanceof Date ? current.getTime() : null;
-  const savedTime = saved instanceof Date ? saved.getTime() : null;
-  return currentTime === savedTime;
-}
-function idArrayEquals(current, saved) {
-  const currentIds = new Set(Array.isArray(current) ? current.map(String) : []);
-  const savedIds = new Set(Array.isArray(saved) ? saved.map(String) : []);
-  if (currentIds.size !== savedIds.size) return false;
-  for (const currentId of currentIds) {
-    if (!savedIds.has(currentId)) return false;
-  }
-  return true;
-}
-
-// src/boundary/save/link-changes.ts
-var LINK_SAVE_FIELD_POLICY = {
-  id: SAVE_FIELD_POLICY.IGNORED,
-  source: SAVE_FIELD_POLICY.TRACKED,
-  target: SAVE_FIELD_POLICY.TRACKED,
-  type: SAVE_FIELD_POLICY.TRACKED,
-  lag: SAVE_FIELD_POLICY.TRACKED,
-  freeSlackHours: SAVE_FIELD_POLICY.IGNORED,
-  isCritical: SAVE_FIELD_POLICY.IGNORED,
-  ganttId: SAVE_FIELD_POLICY.IGNORED,
-  sectorId: SAVE_FIELD_POLICY.IGNORED,
-  proplannerId: SAVE_FIELD_POLICY.IGNORED
-};
-var TRACKED_LINK_FIELDS = Object.keys(LINK_SAVE_FIELD_POLICY).filter((field) => {
-  return LINK_SAVE_FIELD_POLICY[field] === SAVE_FIELD_POLICY.TRACKED;
-});
-function linkChangedSince(baseline, current) {
-  return TRACKED_LINK_FIELDS.some(
-    (field) => baseline[field] !== current[field]
-  );
-}
-function checkNoUpdatedLinks(baseline, current) {
-  const baselineById = new Map(
-    baseline.map((link) => [String(link.id), link])
-  );
-  return current.filter((link) => {
-    const base = baselineById.get(String(link.id));
-    if (!base) return false;
-    return linkChangedSince(base, link);
-  });
-}
-
 // src/previsualization/canonical-digest.ts
 function normalized(value) {
   if (value === void 0) return ["undefined"];
@@ -25749,6 +27552,30 @@ var SaveTracker = class _SaveTracker {
   hasCheckpointLinkId(linkId) {
     return this.linksAtLastSave.has(linkId);
   }
+  rebaseBaseline(activities, links) {
+    return {
+      activities: activities.map((activity) => {
+        const saved = this.p6ActivitiesAtLastSave.get(String(activity.id));
+        return saved === void 0 ? activity : { ...activity, p6: cloneDomainValue(saved) };
+      }),
+      links,
+      p6Settings: cloneDomainValue(this.p6SettingsAtLastSave),
+      p6ProjectState: cloneDomainValue(this.p6ProjectStateAtLastSave),
+      p6LatestRunLog: cloneDomainValue(this.p6LatestRunLogAtLastSave)
+    };
+  }
+  checkpointActivity(activityId) {
+    return this.activitiesAtLastSave.get(activityId)?.persistable ?? null;
+  }
+  checkpointLink(linkId) {
+    return this.linksAtLastSave.get(linkId) ?? null;
+  }
+  checkpointActivityIds() {
+    return [...this.activitiesAtLastSave.keys()];
+  }
+  checkpointLinkIds() {
+    return [...this.linksAtLastSave.keys()];
+  }
   hasUnsavedChanges() {
     return this.trackingEnabled && this.initialized && (this.dirtyActivityIds.size > 0 || this.dirtyLinkIds.size > 0 || this.p6TrackingEnabled && (this.dirtyP6ActivityIds.size > 0 || this.p6SettingsIsDirty() || this.p6ProjectStateDirty || this.p6LatestRunLogDirty));
   }
@@ -25868,332 +27695,6 @@ var SaveTracker = class _SaveTracker {
   }
 };
 
-// src/boundary/backend/normalize-activity.ts
-function normalizeActivities(rawActivities, context) {
-  const hiddenIds = [];
-  const activities = rawActivities.map((raw) => {
-    const activity = parseActivity(raw, context);
-    if (raw.should_be_showed === false) hiddenIds.push(activity.id);
-    return activity;
-  });
-  forceRootProjectToRoot(activities);
-  const activityIds = new Set(activities.map((activity) => activity.id));
-  reparentOrphansToRoot(
-    activities,
-    activityIds,
-    context.reporter,
-    context.recordDiagnostic
-  );
-  return { activities, activityIds, hiddenIds };
-}
-function parseConstraintLabel(label, reporter, recordDiagnostic, activityId) {
-  if (!label) return null;
-  const normalized2 = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
-  if (normalized2 === void 0) {
-    recordDiagnostic(LOAD_DIAGNOSTIC_CODE.UNKNOWN_CONSTRAINT, activityId);
-    reporter.warn(
-      `[parseFromBackend] unknown constraint label "${label}" \u2014 defaulting to "asap"`
-    );
-    return DEFAULT_CONSTRAINT_TYPE;
-  }
-  return normalized2;
-}
-function resolveConstraint(raw, reporter, recordDiagnostic) {
-  const constraintType = parseConstraintLabel(
-    raw.constraint,
-    reporter,
-    recordDiagnostic,
-    String(raw.unique_id)
-  );
-  const constraintTakesDate = constraintType !== CONSTRAINT_TYPE.ASAP && constraintType !== CONSTRAINT_TYPE.ALAP;
-  const constraintDate = constraintTakesDate && raw.constraint_date ? parseBackendDate(raw.constraint_date) : null;
-  return { constraintType, constraintDate };
-}
-function resolveCalendarId2(rawCalendarId, knownCalendarIds, defaultCalendarId) {
-  if (rawCalendarId == null) return defaultCalendarId;
-  const coerced = String(rawCalendarId);
-  return knownCalendarIds.has(coerced) ? coerced : defaultCalendarId;
-}
-function parseNewActivityIds(raw) {
-  if (raw == null || raw === "") return [];
-  if (Array.isArray(raw)) return raw.map(String);
-  if (typeof raw !== "string") return [];
-  try {
-    const parsed2 = JSON.parse(raw);
-    return Array.isArray(parsed2) ? parsed2.map(String) : [];
-  } catch {
-    return [];
-  }
-}
-function hasUsableId(entry) {
-  if (typeof entry !== "object" || entry === null) return false;
-  if (!("id" in entry)) return false;
-  const value = entry.id;
-  return typeof value === "string" || typeof value === "number";
-}
-function parseIdList(raw) {
-  if (!Array.isArray(raw)) return [];
-  const ids = [];
-  for (const entry of raw) {
-    if (hasUsableId(entry)) ids.push(String(entry.id));
-  }
-  return ids;
-}
-function parseParentId(rawParentId) {
-  return rawParentId === ROOT_PARENT_ID ? null : String(rawParentId);
-}
-function normalizePersistedActivityId(rawId) {
-  if (rawId == null) return null;
-  const isValidIdentity = typeof rawId === "number" && (rawId === 0 || Number.isSafeInteger(rawId) && rawId > 0);
-  if (!isValidIdentity) {
-    throw new Error(`invalid activity proplannerId ${String(rawId)}`);
-  }
-  return rawId;
-}
-function parseProgress(raw, reporter, recordDiagnostic, activityId) {
-  const progress = Number(raw);
-  if (!Number.isFinite(progress)) {
-    throw new TypeError(`invalid activity progress ${String(raw)}`);
-  }
-  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;
-  reporter.error(
-    "[parseFromBackend] invalid activity is_critical \u2014 defaulting to false",
-    new TypeError(
-      `activity "${raw.unique_id}" received ${typeof raw.is_critical}`
-    )
-  );
-  return false;
-}
-function parseBaselinePoints(raw, reporter, recordDiagnostic, activityId, isMilestone) {
-  if (!Array.isArray(raw)) return [];
-  return raw.map(
-    (point) => normalizeBaselinePoint(
-      point,
-      reporter,
-      {
-        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,
-    projectBaselineVarianceDays: null,
-    primaryBaselineVarianceDays: 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-link.ts
-function resolveLinkType(rawType) {
-  if (typeof rawType !== "string") return null;
-  const fromLabel = parseLinkTypeCode(rawType);
-  if (fromLabel) return fromLabel;
-  if (isLinkType(rawType)) return rawType;
-  return null;
-}
-function normalizePersistedLinkId(rawId) {
-  if (rawId == null) return void 0;
-  const isValidIdentity = typeof rawId === "number" && (rawId === 0 || Number.isSafeInteger(rawId) && rawId > 0);
-  if (!isValidIdentity) {
-    throw new Error(`invalid link proplannerId ${String(rawId)}`);
-  }
-  return rawId;
-}
-function normalizeLinks(rawLinks, context) {
-  const parsedLinks = [];
-  for (const rawLink of rawLinks) {
-    try {
-      parsedLinks.push(
-        parseLink(rawLink, context.knownActivityIds, context.hoursPerDay)
-      );
-    } catch (parseError2) {
-      context.recordDiagnostic(
-        LOAD_DIAGNOSTIC_CODE.INVALID_LINK,
-        String(rawLink.unique_id ?? rawLink.id)
-      );
-      context.reporter.warn(
-        "[parseFromBackend] dropping invalid link",
-        parseError2
-      );
-    }
-  }
-  return dedupeLinksBySignature(parsedLinks, context.recordDiagnostic);
-}
-function parseLink(link, activityIds, hoursPerDay) {
-  const id = String(link.unique_id ?? link.id);
-  const source = String(link.source_id ?? link.source ?? "");
-  const target = String(link.target_id ?? link.target ?? "");
-  if (!activityIds.has(source)) {
-    throw new Error(
-      `[parseFromBackend] link "${id}" source "${source}" does not exist`
-    );
-  }
-  if (!activityIds.has(target)) {
-    throw new Error(
-      `[parseFromBackend] link "${id}" target "${target}" does not exist`
-    );
-  }
-  const type = resolveLinkType(link.type);
-  if (type === null) {
-    throw new Error(
-      `[parseFromBackend] link "${id}" has invalid type "${String(link.type)}"`
-    );
-  }
-  const ganttIdRaw = link.ganttId;
-  const sectorIdRaw = link.sectorId;
-  const proplannerId = normalizePersistedLinkId(link.id);
-  return {
-    id,
-    source,
-    target,
-    type,
-    lag: lagDaysToHours(Number(link.lag ?? 0), hoursPerDay),
-    freeSlackHours: null,
-    isCritical: false,
-    ...typeof ganttIdRaw === "number" ? { ganttId: ganttIdRaw } : {},
-    ...typeof sectorIdRaw === "number" ? { sectorId: sectorIdRaw } : {},
-    ...proplannerId === void 0 ? {} : { proplannerId }
-  };
-}
-function dedupeLinksBySignature(links, recordDiagnostic) {
-  const bySignature = /* @__PURE__ */ new Map();
-  for (const link of links) {
-    const signature = `${link.source}-${link.target}-${link.type}`;
-    const existing = bySignature.get(signature);
-    if (!existing) {
-      bySignature.set(signature, link);
-      continue;
-    }
-    const incomingWins = linkIdAsNumber(link) > linkIdAsNumber(existing);
-    const discarded = incomingWins ? existing : link;
-    recordDiagnostic(LOAD_DIAGNOSTIC_CODE.DUPLICATE_LINK, discarded.id);
-    if (incomingWins) {
-      bySignature.set(signature, link);
-    }
-  }
-  return [...bySignature.values()];
-}
-function linkIdAsNumber(link) {
-  const numeric = Number(link.id);
-  return Number.isFinite(numeric) ? numeric : -Infinity;
-}
-
 // src/boundary/backend/normalize-sector.ts
 function parseActivityCreter(raw) {
   if (typeof raw !== "string") return DEFAULT_ACTIVITY_CRETER;
@@ -29245,8 +30746,8 @@ function normalizeLatestConstraintDate(input) {
   });
 }
 function isMidnightFinishConstraint(constraintType, constraintDate) {
-  const isMidnight = constraintDate.getUTCHours() === 0 && constraintDate.getUTCMinutes() === 0 && constraintDate.getUTCSeconds() === 0 && constraintDate.getUTCMilliseconds() === 0;
-  return isMidnight && (constraintType === "fnlt" || constraintType === "mfo");
+  const isMidnight2 = constraintDate.getUTCHours() === 0 && constraintDate.getUTCMinutes() === 0 && constraintDate.getUTCSeconds() === 0 && constraintDate.getUTCMilliseconds() === 0;
+  return isMidnight2 && (constraintType === "fnlt" || constraintType === "mfo");
 }
 function constrainLatestFinish(activity, latestFinish, adapter) {
   const bounds = computeConstraintBounds(activity, adapter);
@@ -32025,8 +33526,36 @@ function emptyChangeSet2(source) {
     trackingEvents: []
   };
 }
+function resolvePersistenceAcknowledgement(action, result, saveTracker) {
+  if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
+    return {
+      checkpoint: action.checkpoint,
+      historyBoundary: action.checkpoint?.historyBoundary,
+      persistedActivities: action.activities,
+      persistedLinks: action.links,
+      clearsHistory: false
+    };
+  }
+  if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_REBASE) {
+    const rebaseCheckpoint = result.__rebaseCheckpoint;
+    if (rebaseCheckpoint === void 0) {
+      throw new Error("rebase-on-success requires a rebase checkpoint");
+    }
+    return {
+      checkpoint: saveTracker.rebaseBaseline(
+        rebaseCheckpoint.activities,
+        rebaseCheckpoint.links
+      ),
+      historyBoundary: void 0,
+      persistedActivities: void 0,
+      persistedLinks: void 0,
+      clearsHistory: true
+    };
+  }
+  throw new Error("checkpoint-on-success requires persistence acknowledge");
+}
 function acknowledgesPersistence(action) {
-  return action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true;
+  return action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE || action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_REBASE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true;
 }
 function changesRequireFilterProjectionRebuild(changes) {
   for (const change of changes.activities) {
@@ -33671,6 +35200,7 @@ var ScheduleCore = class _ScheduleCore {
         linkIdGen: this.coreRuntime.linkIdGenerator,
         isActivityIdReserved: (activityId) => this._saveTracker.hasCheckpointActivityId(activityId),
         isLinkIdReserved: (linkId) => this._saveTracker.hasCheckpointLinkId(linkId),
+        persistenceCheckpoint: this._saveTracker,
         uidGen: this.coreRuntime.uniqueCorrelativeIdGenerator,
         customIdTracker: this.coreRuntime.customIdTracker,
         reporter: this.coreRuntime.reporter,
@@ -33760,32 +35290,37 @@ var ScheduleCore = class _ScheduleCore {
       );
     }
     if (result.ok) {
-      if (historyPolicy === DISPATCH_HISTORY_POLICY.CHECKPOINT_ON_SUCCESS) {
-        if (action.kind !== DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
-          throw new Error(
-            "checkpoint-on-success requires persistence acknowledge"
-          );
-        }
+      if (historyPolicy === DISPATCH_HISTORY_POLICY.CHECKPOINT_ON_SUCCESS || historyPolicy === DISPATCH_HISTORY_POLICY.REBASE_ON_SUCCESS) {
+        const acknowledgement = resolvePersistenceAcknowledgement(
+          action,
+          result,
+          this._saveTracker
+        );
         const currentActivities = this.coreRuntime.state.getAllActivities();
         const currentLinks = this.coreRuntime.state.getAllLinks();
-        const checkpoint = action.checkpoint;
-        const boundary = checkpoint?.historyBoundary ?? this._undo.capturePersistenceBoundary();
+        const checkpoint = acknowledgement.checkpoint;
         this._saveTracker.acknowledge(
           checkpoint?.activities ?? currentActivities,
           checkpoint?.links ?? currentLinks,
-          action.activities,
-          action.links,
+          acknowledgement.persistedActivities,
+          acknowledgement.persistedLinks,
           currentActivities,
           currentLinks,
           checkpoint?.p6Settings ?? this.coreRuntime.state.dataDateSettings(),
           checkpoint?.p6ProjectState === void 0 ? this.coreRuntime.state.dataDateProjectState() : checkpoint.p6ProjectState,
           checkpoint?.p6LatestRunLog === void 0 ? this.coreRuntime.state.dataDateLatestRunLog() : checkpoint.p6LatestRunLog
         );
-        this._undo.discardThrough(boundary);
-        this._undo.applyPersistedIdentities(
-          action.activities ?? [],
-          action.links ?? []
-        );
+        if (acknowledgement.clearsHistory) {
+          this._undo.clear();
+        } else {
+          this._undo.discardThrough(
+            acknowledgement.historyBoundary ?? this._undo.capturePersistenceBoundary()
+          );
+          this._undo.applyPersistedIdentities(
+            acknowledgement.persistedActivities ?? [],
+            acknowledgement.persistedLinks ?? []
+          );
+        }
       } else if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true) {
         this._saveTracker.acknowledgePersistedLookahead(
           result.changes.activities,
@@ -34349,6 +35884,7 @@ function toPublicDispatchResult(result) {
   const {
     __beforeSnap: droppedSnapshots,
     __beforeLinks: droppedLinks,
+    __rebaseCheckpoint: droppedRebaseCheckpoint,
     ...publicResult
   } = result;
   return publicResult;
@@ -35230,6 +36766,8 @@ exports.NOT_STARTED_PROGRESS = NOT_STARTED_PROGRESS;
 exports.ORDER_DIRECTION = ORDER_DIRECTION;
 exports.ORDER_MODE = ORDER_MODE;
 exports.PASTE_PLACEMENT = PASTE_PLACEMENT;
+exports.PERSISTENCE_REBASE_CONFLICT_KIND = PERSISTENCE_REBASE_CONFLICT_KIND;
+exports.PERSISTENCE_REBASE_ENTITY = PERSISTENCE_REBASE_ENTITY;
 exports.REJECTION_REASON = REJECTION_REASON;
 exports.ROOT_PARENT_ID = ROOT_PARENT_ID;
 exports.SCHEDULE_CORE_STATUS = SCHEDULE_CORE_STATUS;