@outbuild-company/schedule-core 1.7.0 → 1.9.0

package/dist/index.js

@@ -139,12 +139,11 @@ var REJECTION_REASON = {
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
   PARENT_FROZEN_BY_SIR: "parent_frozen_by_sir",
-  SIR_REQUEST_NOT_PENDING: "sir_request_not_pending",
-  PREVIEW_UNSUPPORTED_ACTION: "preview_unsupported_action",
   CANNOT_MOVE_INTO_OWN_DESCENDANT: "cannot_move_into_own_descendant",
   INDENT_NO_ELIGIBLE_SIBLING: "indent_no_eligible_sibling",
   OUTDENT_ROOT_LEVEL_NOT_EDITABLE: "outdent_root_level_not_editable",
   HIERARCHY_CYCLE: "hierarchy_cycle",
+  SANDBOX_PERSISTENCE_FORBIDDEN: "sandbox_persistence_forbidden",
   INVALID_PROGRESS_VALUE: "invalid_progress_value_must_be_0_or_100"
 };
 
@@ -419,6 +418,107 @@ function getFieldDescriptor(field) {
   return FIELD_REGISTRY[field] ?? null;
 }
 
+// src/internal/state/view-state.ts
+function isRelativePlacementPinValid(activityId, pin, parentOf) {
+  const branchParentId = String(pin.branchParentId);
+  const currentParentId = String(parentOf(activityId) ?? "0");
+  if (currentParentId !== branchParentId) return false;
+  const referenceId = String(pin.referenceId);
+  return referenceId === branchParentId || String(parentOf(referenceId) ?? "0") === branchParentId;
+}
+var ViewStateStore = class {
+  checkedSet = /* @__PURE__ */ new Set();
+  hiddenSet = /* @__PURE__ */ new Set();
+  activeFilter = null;
+  activeOrder = null;
+  relativePlacementPins = /* @__PURE__ */ new Map();
+  isChecked(activityId) {
+    return this.checkedSet.has(activityId);
+  }
+  isVisible(activityId) {
+    return !this.hiddenSet.has(activityId);
+  }
+  hiddenIds() {
+    return [...this.hiddenSet];
+  }
+  getActiveFilter() {
+    return this.activeFilter;
+  }
+  setActiveFilter(nextFilter) {
+    this.activeFilter = nextFilter;
+  }
+  getActiveOrder() {
+    return this.activeOrder;
+  }
+  setActiveOrder(nextOrder) {
+    this.activeOrder = nextOrder;
+  }
+  setRelativePlacementPin(activityId, pin) {
+    this.relativePlacementPins.set(String(activityId), {
+      referenceId: String(pin.referenceId),
+      branchParentId: String(pin.branchParentId),
+      side: pin.side
+    });
+  }
+  getRelativePlacementPins() {
+    return this.relativePlacementPins;
+  }
+  restoreRelativePlacementPins(pins) {
+    this.relativePlacementPins = new Map(pins);
+  }
+  checkedIds() {
+    return [...this.checkedSet];
+  }
+  checkedCount() {
+    return this.checkedSet.size;
+  }
+  setChecked(activityId, nextChecked) {
+    if (nextChecked === this.checkedSet.has(activityId)) return false;
+    if (nextChecked) this.checkedSet.add(activityId);
+    else this.checkedSet.delete(activityId);
+    return true;
+  }
+  setVisible(activityId, nextVisible) {
+    if (nextVisible === !this.hiddenSet.has(activityId)) return false;
+    if (nextVisible) this.hiddenSet.delete(activityId);
+    else this.hiddenSet.add(activityId);
+    return true;
+  }
+  forget(activityId) {
+    this.checkedSet.delete(activityId);
+    this.hiddenSet.delete(activityId);
+    this.relativePlacementPins.delete(activityId);
+    for (const [pinnedId, pin] of this.relativePlacementPins) {
+      if (pin.referenceId === activityId) {
+        this.relativePlacementPins.delete(pinnedId);
+      }
+    }
+  }
+  hydrate(seed2) {
+    this.checkedSet = new Set(seed2.checkedIds ?? []);
+    this.hiddenSet = new Set(seed2.hiddenIds ?? []);
+    this.activeFilter = null;
+    this.activeOrder = null;
+    this.relativePlacementPins = /* @__PURE__ */ new Map();
+  }
+  snapshot() {
+    return {
+      checked: new Set(this.checkedSet),
+      hidden: new Set(this.hiddenSet),
+      activeFilter: this.activeFilter,
+      activeOrder: this.activeOrder,
+      relativePlacementPins: new Map(this.relativePlacementPins)
+    };
+  }
+  restore(snapshot) {
+    this.checkedSet = new Set(snapshot.checked);
+    this.hiddenSet = new Set(snapshot.hidden);
+    this.activeFilter = snapshot.activeFilter;
+    this.activeOrder = snapshot.activeOrder;
+    this.relativePlacementPins = new Map(snapshot.relativePlacementPins);
+  }
+};
+
 // src/internal/filter/evaluate-filter.ts
 function toTargetDate(value) {
   if (value instanceof Date) return value;
@@ -561,13 +661,8 @@ function seedFilterProjection(input) {
       );
     }
     const isMatch = matchesFilter(activity, filter, context);
-    const isPinned = input.pinnedVisibleIds?.has(activityId) === true;
-    visibleReferenceCounts.set(
-      activityId,
-      (isMatch ? 1 : 0) + (isPinned ? 1 : 0)
-    );
+    visibleReferenceCounts.set(activityId, isMatch ? 1 : 0);
     if (isMatch) matchedIds.add(activityId);
-    if (isPinned) pinnedVisibleIds.add(activityId);
   }
   return {
     matchedIds,
@@ -577,6 +672,29 @@ function seedFilterProjection(input) {
     remainingChildren
   };
 }
+function applyRelativePlacementPins(seed2, pins) {
+  if (pins === void 0) return;
+  for (const [activityId, pin] of pins) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    if (!seed2.parentIds.has(pinnedId) || !seed2.parentIds.has(referenceId) || !isRelativePlacementPinValid(
+      pinnedId,
+      pin,
+      (activityId2) => seed2.parentIds.get(activityId2) ?? null
+    ) || (seed2.visibleReferenceCounts.get(referenceId) ?? 0) === 0) {
+      continue;
+    }
+    seed2.pinnedVisibleIds.add(pinnedId);
+    let currentId = pinnedId;
+    while (currentId !== null) {
+      seed2.visibleReferenceCounts.set(
+        currentId,
+        (seed2.visibleReferenceCounts.get(currentId) ?? 0) + 1
+      );
+      currentId = seed2.parentIds.get(currentId) ?? null;
+    }
+  }
+}
 function propagateVisibleReferenceCounts(seed2) {
   const { visibleReferenceCounts, parentIds, remainingChildren } = seed2;
   const pendingIds = [];
@@ -608,6 +726,7 @@ function collectVisibleIds(visibleReferenceCounts) {
 function buildFilterProjection(input) {
   const seed2 = seedFilterProjection(input);
   propagateVisibleReferenceCounts(seed2);
+  applyRelativePlacementPins(seed2, input.relativePlacementPins);
   const visibleIds = collectVisibleIds(seed2.visibleReferenceCounts);
   return {
     filter: input.filter,
@@ -795,7 +914,8 @@ function resolveFilter(adapter, filter, hoursPerDay) {
     activities,
     parentOf: (activityId) => adapter.getParentId(activityId),
     filter,
-    context: buildFilterContext(hoursPerDay)
+    context: buildFilterContext(hoursPerDay),
+    relativePlacementPins: adapter.getRelativePlacementPins()
   });
   return { visibleIds: projection.visibleIds, projection };
 }
@@ -846,25 +966,118 @@ function normalizeParentKey(parent) {
 
 // src/internal/hierarchy/visual-order.ts
 var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-function getChildrenInVisualOrder(parentId, adapter) {
+var EMPTY_RELATIVE_PLACEMENT_PINS = /* @__PURE__ */ new Map();
+function buildRelativePlacementPinIndex(adapter) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [activityId, pin] of adapter.getRelativePlacementPins?.() ?? []) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    if (adapter.getActivity(pinnedId) === null || adapter.getActivity(referenceId) === null || !isRelativePlacementPinValid(
+      pinnedId,
+      pin,
+      (activityId2) => adapter.getParentId(activityId2)
+    )) {
+      continue;
+    }
+    const targetParentId = String(pin.branchParentId);
+    const branchPins = index.get(targetParentId) ?? /* @__PURE__ */ new Map();
+    branchPins.set(pinnedId, pin);
+    index.set(targetParentId, branchPins);
+  }
+  return index;
+}
+function getChildrenInVisualOrder(parentId, adapter, pinIndex = buildRelativePlacementPinIndex(adapter)) {
   const children = collectChildrenSnapshots(parentId, adapter);
   const userOrder = adapter.getOrderComparator?.() ?? null;
   children.sort(
     userOrder === null ? compareActivitiesInVisualOrder : (a, b) => userOrder(a, b) || compareActivitiesInVisualOrder(a, b)
   );
-  return children.map((a) => String(a.id));
+  return applyRelativePlacementPins2(
+    children.map((activity) => String(activity.id)),
+    parentId,
+    pinIndex.get(String(parentId)) ?? EMPTY_RELATIVE_PLACEMENT_PINS
+  );
+}
+function applyRelativePlacementPins2(orderedIds, parentId, pins) {
+  const order = buildLinkedActivityOrder(orderedIds);
+  for (const [activityId, pin] of pins) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    const isFirstChild = referenceId === String(parentId);
+    if (!order.previous.has(pinnedId) || !isFirstChild && (!order.previous.has(referenceId) || pinnedId === referenceId)) {
+      continue;
+    }
+    detachActivity(order, pinnedId);
+    if (isFirstChild) insertActivityFirst(order, pinnedId);
+    else insertActivityBeside(order, pinnedId, referenceId, pin.side);
+  }
+  return materializeActivityOrder(order);
+}
+function buildLinkedActivityOrder(orderedIds) {
+  const previous = /* @__PURE__ */ new Map();
+  const next = /* @__PURE__ */ new Map();
+  for (let index = 0; index < orderedIds.length; index++) {
+    const activityId = orderedIds[index];
+    if (activityId === void 0) continue;
+    previous.set(activityId, orderedIds[index - 1] ?? null);
+    next.set(activityId, orderedIds[index + 1] ?? null);
+  }
+  return { previous, next, head: orderedIds[0] ?? null };
+}
+function detachActivity(order, activityId) {
+  const before = order.previous.get(activityId) ?? null;
+  const after = order.next.get(activityId) ?? null;
+  if (before === null) order.head = after;
+  else order.next.set(before, after);
+  if (after !== null) order.previous.set(after, before);
+}
+function insertActivityFirst(order, activityId) {
+  order.previous.set(activityId, null);
+  order.next.set(activityId, order.head);
+  if (order.head !== null) order.previous.set(order.head, activityId);
+  order.head = activityId;
+}
+function insertActivityBeside(order, activityId, referenceId, side) {
+  if (side === "before") {
+    const before = order.previous.get(referenceId) ?? null;
+    order.previous.set(activityId, before);
+    order.next.set(activityId, referenceId);
+    order.previous.set(referenceId, activityId);
+    if (before === null) order.head = activityId;
+    else order.next.set(before, activityId);
+    return;
+  }
+  const after = order.next.get(referenceId) ?? null;
+  order.previous.set(activityId, referenceId);
+  order.next.set(activityId, after);
+  order.next.set(referenceId, activityId);
+  if (after !== null) order.previous.set(after, activityId);
+}
+function materializeActivityOrder(order) {
+  const result = [];
+  let activityId = order.head;
+  while (activityId !== null) {
+    result.push(activityId);
+    activityId = order.next.get(activityId) ?? null;
+  }
+  return result;
 }
 function iterateInVisualOrder(adapter) {
   const result = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (activity) => {
     result.push(activity);
-    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
+    const childIds = getChildrenInVisualOrder(
+      String(activity.id),
+      adapter,
+      pinIndex
+    );
     for (const childId of childIds) {
       const child = adapter.getActivity(childId);
       if (child) visit(child);
     }
   };
-  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter, pinIndex);
   for (const rootId of rootIds) {
     const root = adapter.getActivity(rootId);
     if (root) visit(root);
@@ -925,8 +1138,9 @@ function setHas(set, id) {
 // src/dispatch/shared/collect-branch-order.ts
 function collectBranchOrder(adapter) {
   const branches = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (parentId) => {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
     if (childIds.length > 1) {
       branches.push({ parentId, childIds });
     }
@@ -939,8 +1153,9 @@ function collectBranchOrder(adapter) {
 }
 function collectBranchOrderForParents(adapter, parentIds) {
   const branches = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   for (const parentId of parentIds) {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
     if (childIds.length > 1) branches.push({ parentId, childIds });
   }
   return branches;
@@ -1791,6 +2006,8 @@ function buildVirtualLink(originalLink, sourceId, targetId, counter, sourceLag,
     target: targetId,
     type: originalLink.type,
     lag: originalLink.lag,
+    freeSlackHours: null,
+    isCritical: false,
     _sourceLag: sourceLag,
     _targetLag: targetLag,
     _trueLag: trueLag,
@@ -2868,7 +3085,9 @@ function applyLinkCreates(links, deps) {
       source: operation.source,
       target: operation.target,
       type: operation.type,
-      lag: operation.lag
+      lag: operation.lag,
+      freeSlackHours: null,
+      isCritical: false
     }))
   ];
   const effectiveVerdict = validateTopologyCommit({
@@ -2887,6 +3106,8 @@ function applyLinkCreates(links, deps) {
       target: operation.target,
       type: operation.type,
       lag: operation.lag,
+      freeSlackHours: null,
+      isCritical: false,
       ...preserved?.ganttId === void 0 ? {} : { ganttId: preserved.ganttId },
       ...preserved?.sectorId === void 0 ? {} : { sectorId: preserved.sectorId },
       ...preserved?.proplannerId === void 0 ? {} : { proplannerId: preserved.proplannerId }
@@ -2929,7 +3150,9 @@ function applyCreate(op, deps) {
     source: op.source,
     target: op.target,
     type: op.type,
-    lag: op.lag
+    lag: op.lag,
+    freeSlackHours: null,
+    isCritical: false
   };
   const effectiveVerdict = validateTopologyCommit({
     port,
@@ -3443,19 +3666,44 @@ async function recomputeParentsCooperatively(parents, adapter, progressMode, opt
 }
 function findAncestorsOfDirty(adapter, dirtyIds) {
   const ancestors = /* @__PURE__ */ new Set();
-  for (const id of dirtyIds) walkAncestors(id, adapter, ancestors);
+  const parentById = /* @__PURE__ */ new Map();
+  for (const id of dirtyIds) {
+    walkAncestors(id, adapter, ancestors, parentById);
+  }
   if (ancestors.size === 0) return [];
   const ids = Array.from(ancestors);
-  const depths = computeDepths(ids, adapter);
+  const depths = computeKnownDepths(ids, parentById);
   return sortDeepestFirst(ids, depths);
 }
-function walkAncestors(id, adapter, collector) {
+function walkAncestors(id, adapter, collector, parentById) {
   let current = adapter.getParentId(id);
   while (current && !isRootParent(current)) {
     if (collector.has(current)) return;
     collector.add(current);
-    current = adapter.getParentId(current);
+    const parent = adapter.getParentId(current);
+    parentById.set(current, parent);
+    current = parent;
+  }
+}
+function computeKnownDepths(ids, parentById) {
+  const depths = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    if (depths.has(id)) continue;
+    const path = [];
+    const inPath = /* @__PURE__ */ new Set();
+    let current = id;
+    while (current && !isRootParent(current) && !depths.has(current) && !inPath.has(current)) {
+      path.push(current);
+      inPath.add(current);
+      current = parentById.get(current) ?? null;
+    }
+    let depth = current ? depths.get(current) ?? 0 : 0;
+    for (let index = path.length - 1; index >= 0; index -= 1) {
+      depth += 1;
+      depths.set(path[index], depth);
+    }
   }
+  return depths;
 }
 function aggregateChildren(childrenIds, adapter, includeRealWork) {
   let minStart = null;
@@ -3679,19 +3927,6 @@ function durationToHours(durationDays, hoursPerDay) {
   return Math.round(Math.ceil(durationDays * hoursPerDay * 60) / 60);
 }
 
-// src/columns/shared/error-codes.ts
-var PARSE_ERROR = {
-  NOT_A_NUMBER: "not_a_number",
-  // ISSUE-057 (CP6): la unidad de una duración se declara, no se adivina.
-  MISSING_INPUT_UNIT: "missing_input_unit",
-  // D-OWNER-5: una duración en días es entera; una fracción se rechaza sin
-  // redondear (el redondeo silencioso era la puerta del bug de las 320 horas).
-  FRACTIONAL_DAYS: "fractional_days"
-};
-var VALIDATION_REASON = {
-  UNCHANGED: "unchanged",
-  NEGATIVE_DURATION: "negative_duration"};
-
 // src/columns/end-date/setter.ts
 var setEndDate = (value) => ({
   endDate: value
@@ -3793,6 +4028,10 @@ var POST_PROCESSOR = {
   RECORD_LAST_START_DATE: "recordLastStartDate"
 };
 
+// src/columns/shared/error-codes.ts
+var VALIDATION_REASON = {
+  NEGATIVE_DURATION: "negative_duration"};
+
 // src/columns/shared/constraint-validation.ts
 function checkConstraintViolation2(constraintType, constraintDate, projectedDate) {
   return checkConstraintViolation(constraintType, constraintDate, projectedDate);
@@ -3817,18 +4056,7 @@ var durationPipeline = {
   },
   parseInput(rawValue, _activity, ctx) {
     const numericValue = parseFloat(String(rawValue));
-    if (!Number.isFinite(numericValue)) {
-      return parseError(PARSE_ERROR.NOT_A_NUMBER);
-    }
-    if (ctx.inputUnit === void 0) {
-      return parseError(PARSE_ERROR.MISSING_INPUT_UNIT);
-    }
-    if (ctx.inputUnit === "hours") {
-      return parsed(numericValue);
-    }
-    if (!Number.isInteger(numericValue)) {
-      return parseError(PARSE_ERROR.FRACTIONAL_DAYS);
-    }
+    if (!Number.isFinite(numericValue)) return parseError("not_a_number");
     return parsed(durationToHours(numericValue, ctx.hoursPerDay));
   },
   validate(_activity, oldValue, newValue) {
@@ -4072,8 +4300,8 @@ var costPipeline = {
     }
     return canEdit();
   },
-  parseInput(rawValue, activity) {
-    if (String(rawValue).trim() === "") return parsed(activity.cost);
+  parseInput(rawValue) {
+    if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
     if (Number.isNaN(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
@@ -4122,8 +4350,8 @@ var usedCostPipeline = {
     }
     return canEdit();
   },
-  parseInput(rawValue, activity) {
-    if (String(rawValue).trim() === "") return parsed(activity.usedCost);
+  parseInput(rawValue) {
+    if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
     if (Number.isNaN(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
@@ -4864,7 +5092,9 @@ var ACTIVITY_PROPERTY = {
   CALENDAR_DURATION: "calendarDuration"};
 var LINK_PROPERTY = {
   TYPE: "type",
-  LAG: "lag"};
+  LAG: "lag",
+  FREE_SLACK_HOURS: "freeSlackHours",
+  IS_CRITICAL: "isCritical"};
 
 // src/internal/state/dynamic-writes.ts
 function setActivityFieldDynamic(state, activityId, field, value) {
@@ -5720,10 +5950,11 @@ function mutateTheDateToFutureOrPastInBaseRestriction(dateBaseToCalculate, restr
 
 // src/critical-path/legacy/base/parents-calculations/forward.js
 var CalculateForwardParentsWithLinks = class {
-  constructor(linkedActivitiesData, activity, gantt) {
+  constructor(linkedActivitiesData, activity, gantt, linkCandidates) {
     this.linkedActivitiesData = linkedActivitiesData;
     this.activity = activity;
     this.gantt = gantt;
+    this.linkCandidates = linkCandidates;
     this.activityCalendar = this.gantt.getCalendar(this.activity.calendar_id);
     if (!this.activityCalendar) {
       throw new Error(
@@ -5768,6 +5999,10 @@ var CalculateForwardParentsWithLinks = class {
         continue;
       }
       if (calculation) {
+        this.linkCandidates?.set(linkedActivity.linkId, {
+          targetId: String(this.activity.id),
+          ...calculation
+        });
         calculations.push(calculation);
       }
     }
@@ -6215,7 +6450,8 @@ function parentWithLinks(params) {
     linkDirection,
     calculations,
     gantt,
-    direction
+    direction,
+    linkCandidates
   } = params;
   const linksArray = parent[linkProperty];
   const parentData = extractParentData(parent);
@@ -6230,7 +6466,8 @@ function parentWithLinks(params) {
     calculation = new forward_default(
       linksWithActivityData,
       parent,
-      gantt
+      gantt,
+      linkCandidates
     );
     calculation = calculation.calculate();
   } else {
@@ -6275,6 +6512,7 @@ function getLinksWithActivityDataForward(linksArray, linkDirection, calculations
       return null;
     }
     return {
+      linkId: String(linkData.id),
       es: calculationsOfLinkedActivity.es,
       ef: calculationsOfLinkedActivity.ef,
       linkLag: linkData.lag,
@@ -6375,6 +6613,7 @@ var CalculationOfParent = class {
     this.calculationOfParentsFromLinks = params.calculationOfParentsFromLinks;
     this.singleParents = params.singleParents;
     this.parentCalculationFromChildren = params.parentCalculationFromChildren;
+    this.linkCandidates = params.linkCandidates;
     this.gantt = params.gantt;
   }
   handleParentWithLinks() {
@@ -6422,7 +6661,8 @@ var CalculationOfParent = class {
       linkDirection: this.linkDirection,
       gantt: this.gantt,
       calculations: this.calculations,
-      direction: this.direction
+      direction: this.direction,
+      linkCandidates: this.linkCandidates
     });
     this.calculationsOfParentThatImpactChildrens.set(activity.id, calculation);
     this.calculationOfParentsFromLinks.add(activity.id);
@@ -7071,6 +7311,7 @@ var CriticalPathHelpers = class {
       calculationOfParentsFromLinks: this.calculationOfParentsFromLinks,
       singleParents: this.singleParents,
       parentCalculationFromChildren: this.parentCalculationFromChildren,
+      linkCandidates: this.linkCandidates,
       gantt: this.gantt
     });
     if (this.pendingParentsWithLinks.has(activity.id)) {
@@ -7138,6 +7379,7 @@ var LinksRulesCalculationsMethods = class {
     this.parentsWithLinks = calculationObject.parentsWithLinks;
     this.parentsCalculations = calculationObject.parentsCalculations;
     this.gantt = calculationObject.ganttInstance;
+    this.linkCandidates = calculationObject.linkCandidates;
   }
   getEsAndEfFromPreviousCalculatedActivities(activity) {
     const isAlap = this.alapMap.has(activity);
@@ -7309,7 +7551,12 @@ var LinksConstraintCalculator = class extends LinksRulesCalculationsMethods_defa
       if (!linkData) {
         throw new Error("Link data not found", { cause: { linkId: link } });
       }
-      return this.calculateLink(linkData);
+      const calculation = this.calculateLink(linkData);
+      this.linkCandidates?.set(String(linkData.id), {
+        targetId: String(this.referenceActivity.id),
+        ...calculation
+      });
+      return calculation;
     });
     const parent = Number(this.referenceActivity.parent);
     if (this.parentsWithLinks.has(parent)) {
@@ -7575,6 +7822,7 @@ var ForwardPath = class extends generic_calculations_default {
     this.totalFloatSnltFnlt = /* @__PURE__ */ new Map();
     this.totalFloatForMsoMfo = /* @__PURE__ */ new Map();
     this.totalFloatForAsap = /* @__PURE__ */ new Map();
+    this.linkCandidates = /* @__PURE__ */ new Map();
     this.calculationOfParentsFromLinks = /* @__PURE__ */ new Set();
     this.parentCalculationFromChildren = /* @__PURE__ */ new Set();
     this.forbiddenActivitiesLinkedToParentsWithLinks = /* @__PURE__ */ new Set();
@@ -7673,7 +7921,8 @@ var ForwardPath = class extends generic_calculations_default {
           constraint: constraintType,
           parentsWithLinks: this.pendingParentsWithLinks,
           parentsCalculations: this.calculationsOfParentThatImpactChildrens,
-          ganttInstance: this.gantt
+          ganttInstance: this.gantt,
+          linkCandidates: this.linkCandidates
         }).calculate();
         if (constraintType === CONSTRAINT_TYPES.ASAP) {
           this.totalFloatForAsap.set(activity, {
@@ -7691,7 +7940,8 @@ var ForwardPath = class extends generic_calculations_default {
           constraint: constraintType,
           parentsWithLinks: this.pendingParentsWithLinks,
           parentsCalculations: this.calculationsOfParentThatImpactChildrens,
-          ganttInstance: this.gantt
+          ganttInstance: this.gantt,
+          linkCandidates: this.linkCandidates
         }).calculate());
       }
       if (constraintType === CONSTRAINT_TYPES.ALAP) {
@@ -8728,7 +8978,6 @@ var BackwardPath = class extends generic_calculations_default {
       }
     }
     if ([CONSTRAINT_TYPES.SNLT].includes(activity.constraint_type)) {
-      const constraintDate = activity.constraint_date;
       const parentLinkCalcualation2 = this.calculationsOfParentThatImpactChildrens.get(parent);
       const lsToComparison = addDurationToDate(
         this.gantt.getCalendar(activity.calendar_id),
@@ -8736,6 +8985,7 @@ var BackwardPath = class extends generic_calculations_default {
         -activity.duration,
         activity
       );
+      const constraintDate = activity.constraint_date ?? lsToComparison;
       ls = new Date(
         Math.min(constraintDate.getTime(), lsToComparison.getTime())
       );
@@ -8747,8 +8997,8 @@ var BackwardPath = class extends generic_calculations_default {
       );
     }
     if ([CONSTRAINT_TYPES.FNLT].includes(activity.constraint_type)) {
-      const constraintDate = activity.constraint_date;
       const parentLinkCalcualation2 = this.calculationsOfParentThatImpactChildrens.get(parent);
+      const constraintDate = activity.constraint_date ?? parentLinkCalcualation2.lf;
       ls = new Date(
         Math.min(constraintDate.getTime(), parentLinkCalcualation2.lf.getTime())
       );
@@ -9132,18 +9382,20 @@ var FreeFloat = class {
     );
   }
   calculateFreeFloatForEndOfProject(constraint) {
+    const calculation = constraint === CONSTRAINT_TYPES.ALAP ? this.backwardMap.get(this.activity.id) : this.forwardMap.get(this.activity.id);
     return this.parseHoursToDays(
       this.calculationWithCalendar(
         this.gantt.getSubtaskDates().end_date,
-        constraint === CONSTRAINT_TYPES.ALAP ? this.backwardMap.get(this.activity.id).lf : this.forwardMap.get(this.activity.id).ef
+        constraint === CONSTRAINT_TYPES.ALAP ? calculation?.lf : calculation?.ef
       )
     );
   }
   calculateFreeFloatOfRestriction(constraint) {
+    const calculation = this.forwardMap.get(this.activity.id);
     return this.parseHoursToDays(
       this.calculationWithCalendar(
         this.activity.constraint_date,
-        constraint === CONSTRAINT_TYPES.FNLT ? this.forwardMap.get(this.activity.id).ef : this.forwardMap.get(this.activity.id).es
+        constraint === CONSTRAINT_TYPES.FNLT ? calculation?.ef : calculation?.es
       )
     );
   }
@@ -9161,111 +9413,33 @@ var FreeFloat = class {
     sucessorId,
     predecessorId
   }) {
-    const getPredecessorDate = ({
-      direction,
-      constraint: constraint2 = CONSTRAINT_TYPES.ASAP
-    }) => {
-      if (constraint2 === CONSTRAINT_TYPES.ALAP) {
-        return this.backwardMap.get(predecessorId)[direction];
+    const successor = (isSuscessorAlap ? this.backwardMap : this.forwardMap).get(sucessorId);
+    const predecessor = (constraint === CONSTRAINT_TYPES.ALAP ? this.backwardMap : this.forwardMap).get(predecessorId);
+    const predecessorStart = constraint === CONSTRAINT_TYPES.ALAP ? predecessor?.ls : predecessor?.es;
+    const predecessorFinish = constraint === CONSTRAINT_TYPES.ALAP ? predecessor?.lf : predecessor?.ef;
+    return {
+      fs: {
+        sucessor: successor?.ls ?? successor?.es,
+        predecessor: predecessorFinish
+      },
+      ss: {
+        sucessor: successor?.ls ?? successor?.es,
+        predecessor: predecessorStart
+      },
+      ff: {
+        sucessor: successor?.lf ?? successor?.ef,
+        predecessor: predecessorFinish
+      },
+      sf: {
+        sucessor: successor?.lf ?? successor?.ef,
+        predecessor: predecessorStart
       }
-      return this.forwardMap.get(predecessorId)[direction];
     };
-    if (constraint === CONSTRAINT_TYPES.ASAP || constraint === CONSTRAINT_TYPES.SNET || constraint === CONSTRAINT_TYPES.FNET || constraint === CONSTRAINT_TYPES.MSO || constraint === CONSTRAINT_TYPES.MFO) {
-      return {
-        fs: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        ss: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "es" })
-        },
-        ff: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        sf: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "es" })
-        }
-      };
-    }
-    if (constraint === CONSTRAINT_TYPES.ALAP) {
-      return {
-        fs: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({
-            constraint: CONSTRAINT_TYPES.ALAP,
-            direction: "lf"
-          })
-        },
-        ss: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({
-            constraint: CONSTRAINT_TYPES.ALAP,
-            direction: "ls"
-          })
-        },
-        ff: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({
-            constraint: CONSTRAINT_TYPES.ALAP,
-            direction: "lf"
-          })
-        },
-        sf: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({
-            constraint: CONSTRAINT_TYPES.ALAP,
-            direction: "ls"
-          })
-        }
-      };
-    }
-    if (constraint === CONSTRAINT_TYPES.SNLT) {
-      return {
-        fs: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        ss: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "es" })
-        },
-        ff: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        sf: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "es" })
-        }
-      };
-    }
-    if (constraint === CONSTRAINT_TYPES.FNLT) {
-      return {
-        fs: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        ss: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).ls : this.forwardMap.get(sucessorId).es,
-          predecessor: getPredecessorDate({ direction: "es" })
-        },
-        ff: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "ef" })
-        },
-        sf: {
-          sucessor: isSuscessorAlap ? this.backwardMap.get(sucessorId).lf : this.forwardMap.get(sucessorId).ef,
-          predecessor: getPredecessorDate({ direction: "es" })
-        }
-      };
-    }
   }
   calculateMsoMfo(constraint) {
     const CONSTRAINT_DATE2 = this.activity.constraint_date || /* @__PURE__ */ new Date();
-    const DATE_TO_CALCULATE = constraint === CONSTRAINT_TYPES.MSO ? this.forwardMap.get(this.activity.id).es : this.forwardMap.get(this.activity.id).ef;
+    const calculation = this.forwardMap.get(this.activity.id);
+    const DATE_TO_CALCULATE = constraint === CONSTRAINT_TYPES.MSO ? calculation?.es : calculation?.ef;
     const freeSlack = this.calculationWithCalendar(
       CONSTRAINT_DATE2,
       DATE_TO_CALCULATE
@@ -9279,6 +9453,9 @@ var FreeFloat = class {
     return filterValues.length ? Math.min(...filterValues) : 0;
   }
   calculationWithCalendar(dateOne, dateTwo) {
+    if (!(dateOne instanceof Date) || !(dateTwo instanceof Date) || !Number.isFinite(dateOne.getTime()) || !Number.isFinite(dateTwo.getTime())) {
+      return Number.NaN;
+    }
     const key = `${dateTwo.getTime()}_${dateOne.getTime()}`;
     if (this.durationCache.has(key)) {
       return this.durationCache.get(key);
@@ -9292,7 +9469,7 @@ var FreeFloat = class {
     return result;
   }
   parseHoursToDays(date2) {
-    if (!date2) {
+    if (date2 === void 0 || date2 === null) {
       return 0;
     }
     return date2 / this.gantt.config.hoursPerDay;
@@ -9358,6 +9535,7 @@ var CriticalPath = class {
     this.backwardPathCalculations = null;
     this.totalFloat = /* @__PURE__ */ new Map();
     this.freeFloat = /* @__PURE__ */ new Map();
+    this.linkResidualHours = /* @__PURE__ */ new Map();
     this.currentCalculationId = 0;
   }
   getCurrentCalculationId = () => this.currentCalculationId;
@@ -9388,6 +9566,13 @@ var CriticalPath = class {
       if (!isCurrent()) return false;
       this.forwardPathCalculations = forwardPathCalculations;
       this.backwardPathCalculations = backwardPath.calculations;
+      const linkResidualHours = await this.calculateLinkResidualHours(
+        forwardPath.linkCandidates,
+        forwardPathCalculations,
+        isCurrent
+      );
+      if (!linkResidualHours || !isCurrent()) return false;
+      this.linkResidualHours = linkResidualHours;
       const { totalFloatMap, freeFloatMap } = await this.calculateFloatsAsync(
         forwardPath,
         backwardPath,
@@ -9407,6 +9592,38 @@ var CriticalPath = class {
       throw error;
     }
   }
+  async calculateLinkResidualHours(linkCandidates, forwardCalculations, isCurrent = () => true) {
+    const residuals = /* @__PURE__ */ new Map();
+    let sliceStartTime = performance.now();
+    for (const [linkId, candidate] of linkCandidates) {
+      sliceStartTime = await yieldIfNeeded2(sliceStartTime);
+      if (!isCurrent()) return null;
+      const targetId = Number(candidate.targetId);
+      const target = this.gantt.getTask(targetId);
+      const settled = forwardCalculations.get(targetId);
+      const candidateEf = candidate.ef;
+      const settledEf = settled?.ef;
+      const calendar = target && this.gantt.getCalendar(target.calendar_id);
+      if (!calendar || !(candidateEf instanceof Date) || !(settledEf instanceof Date) || !Number.isFinite(candidateEf.getTime()) || !Number.isFinite(settledEf.getTime())) {
+        residuals.set(linkId, null);
+        continue;
+      }
+      const candidateTime = candidateEf.getTime();
+      const settledTime = settledEf.getTime();
+      const duration = settledTime >= candidateTime ? calendar.calculateDuration({
+        start_date: candidateEf,
+        end_date: settledEf
+      }) : -calendar.calculateDuration({
+        start_date: settledEf,
+        end_date: candidateEf
+      });
+      residuals.set(
+        linkId,
+        Number.isFinite(duration) ? Object.is(duration, -0) ? 0 : duration : null
+      );
+    }
+    return residuals;
+  }
   async calculateFloatsAsync(forward, backward, isCurrent) {
     try {
       const projectDates = this.gantt.getSubtaskDates();
@@ -9510,14 +9727,52 @@ function computeLevels(state) {
   for (const id of activitiesById.keys()) resolveLevel(id, /* @__PURE__ */ new Set());
   return levelById;
 }
-function toLegacyTasks(state) {
+function createLegacyIds(state) {
+  const canonicalIds = /* @__PURE__ */ new Set();
+  state.forEachActivity((activity, id) => {
+    canonicalIds.add(String(id));
+    if (activity.parentId !== null) canonicalIds.add(String(activity.parentId));
+  });
+  const numericCounts = /* @__PURE__ */ new Map();
+  for (const id of canonicalIds) {
+    const numeric = Number(id);
+    if (Number.isSafeInteger(numeric) && numeric !== 0) {
+      numericCounts.set(numeric, (numericCounts.get(numeric) ?? 0) + 1);
+    }
+  }
+  const canonicalToLegacy = /* @__PURE__ */ new Map();
+  const legacyToCanonical = /* @__PURE__ */ new Map();
+  for (const id of canonicalIds) {
+    const numeric = Number(id);
+    if (Number.isSafeInteger(numeric) && numeric !== 0 && numericCounts.get(numeric) === 1) {
+      canonicalToLegacy.set(id, numeric);
+      legacyToCanonical.set(numeric, id);
+    }
+  }
+  let next = 1;
+  const toLegacy = (rawId) => {
+    const id = String(rawId);
+    const existing = canonicalToLegacy.get(id);
+    if (existing !== void 0) return existing;
+    while (legacyToCanonical.has(next)) next += 1;
+    canonicalToLegacy.set(id, next);
+    legacyToCanonical.set(next, id);
+    return next++;
+  };
+  for (const id of canonicalIds) toLegacy(id);
+  return {
+    toLegacy,
+    toCanonical: (id) => typeof id === "number" ? legacyToCanonical.get(id) ?? null : canonicalToLegacy.has(String(id)) ? String(id) : null
+  };
+}
+function toLegacyTasks(state, ids) {
   const levelById = computeLevels(state);
   const leveled = /* @__PURE__ */ new Map();
   state.forEachActivity((activity, id) => {
     const key = String(id);
     leveled.set(key, {
-      id: Number(id),
-      parent: activity.parentId === null ? 0 : Number(activity.parentId),
+      id: ids.toLegacy(key),
+      parent: activity.parentId === null ? 0 : ids.toLegacy(activity.parentId),
       $level: levelById.get(key) ?? 0,
       $source: state.getOutgoingLinkIds(key),
       $target: state.getIncomingLinkIds(key),
@@ -9591,7 +9846,8 @@ async function createGanttAdapter(state, hoursPerDay) {
   };
   const bounds = projectBounds(state);
   await yieldToBrowser();
-  const leveled = toLegacyTasks(state);
+  const ids = createLegacyIds(state);
+  const leveled = toLegacyTasks(state, ids);
   await yieldToBrowser();
   const byTime = [...leveled.values()].sort(
     (a, b) => (a.start_date?.getTime() ?? 0) - (b.start_date?.getTime() ?? 0)
@@ -9601,24 +9857,31 @@ async function createGanttAdapter(state, hoursPerDay) {
   return {
     fullyParsed: true,
     config: { hoursPerDay },
-    getTask: (id) => leveled.get(String(id)) ?? null,
+    getTask: (id) => {
+      const canonicalId = ids.toCanonical(id);
+      return canonicalId === null ? null : leveled.get(canonicalId) ?? null;
+    },
     getLink: (id) => {
       const link = state.getLink(id);
       if (!link) return null;
       return {
         ...link,
-        source: Number(link.source),
-        target: Number(link.target),
+        source: ids.toLegacy(link.source),
+        target: ids.toLegacy(link.target),
         lag: link.lag
       };
     },
     getCalendar: resolveCalendar,
-    getChildren: (parentId) => state.getChildren(parentId).map((childId) => Number(childId)),
+    getChildren: (parentId) => {
+      const canonicalId = ids.toCanonical(parentId);
+      return canonicalId === null ? [] : state.getChildren(canonicalId).map(ids.toLegacy);
+    },
     eachTask: (cb) => {
       for (const task of treeOrdered) cb(task);
     },
     getTaskByTime: () => byTime,
     getSubtaskDates: () => bounds,
+    getCanonicalActivityId: ids.toCanonical,
     refreshData: () => {
     }
   };
@@ -9626,21 +9889,92 @@ async function createGanttAdapter(state, hoursPerDay) {
 
 // src/critical-path/run-critical-path.ts
 var CP_WRITE_YIELD_EVERY = 1e3;
-function fieldsForActivity(activityId, progress, maps) {
-  const toDate = (value) => value == null ? null : new Date(value);
+function fieldsForLink(rawResidual, sourceIsCritical, targetIsCritical, targetProgress) {
+  const freeSlackHours = typeof rawResidual === "number" && Number.isFinite(rawResidual) ? Object.is(rawResidual, -0) ? 0 : rawResidual : null;
+  return {
+    freeSlackHours,
+    isCritical: freeSlackHours !== null && freeSlackHours <= 0 && sourceIsCritical && targetIsCritical && targetProgress === 0
+  };
+}
+async function collectActivityFields(state, maps, hoursPerDay, toCanonicalActivityId, isCurrent) {
+  const fields = /* @__PURE__ */ new Map();
+  let sinceYield = 0;
+  for (const calculationId of maps.forward?.keys() ?? []) {
+    if (++sinceYield >= CP_WRITE_YIELD_EVERY) {
+      sinceYield = 0;
+      await yieldToBrowser();
+      if (!isCurrent()) return null;
+    }
+    const activityId = toCanonicalActivityId(calculationId);
+    if (activityId === null) continue;
+    const activity = state.getActivity(activityId);
+    if (!activity) continue;
+    fields.set(
+      String(activityId),
+      fieldsForActivity(
+        calculationId,
+        Number(activity.progress ?? 0),
+        maps,
+        hoursPerDay
+      )
+    );
+  }
+  return isCurrent() ? fields : null;
+}
+async function collectLinkFields(state, linkResidualHours, activityFields, isCurrent) {
+  const fields = /* @__PURE__ */ new Map();
+  let sinceYield = 0;
+  for (const link of state.getAllLinks()) {
+    if (++sinceYield >= CP_WRITE_YIELD_EVERY) {
+      sinceYield = 0;
+      await yieldToBrowser();
+      if (!isCurrent()) return null;
+    }
+    fields.set(
+      String(link.id),
+      fieldsForLink(
+        linkResidualHours.get(String(link.id)),
+        activityFields.get(link.source)?.isCritical === true,
+        activityFields.get(link.target)?.isCritical === true,
+        state.getActivity(link.target)?.progress
+      )
+    );
+  }
+  return isCurrent() ? fields : null;
+}
+var slackDaysToHours = (valueDays, hoursPerDay) => {
+  if (typeof valueDays !== "number" || !Number.isFinite(valueDays) || !Number.isFinite(hoursPerDay) || hoursPerDay <= 0) {
+    return null;
+  }
+  const hours = valueDays * hoursPerDay;
+  if (!Number.isFinite(hours)) return null;
+  return Object.is(hours, -0) ? 0 : hours;
+};
+function fieldsForActivity(activityId, progress, maps, hoursPerDay) {
+  const toDate = (value) => {
+    if (value == null) return null;
+    const date2 = new Date(value);
+    return Number.isFinite(date2.getTime()) ? date2 : null;
+  };
   const forward = maps.forward?.get(activityId);
   const backward = maps.backward?.get(activityId);
-  const totalSlack = maps.totalFloat.get(activityId) ?? null;
+  const totalSlackHours = slackDaysToHours(
+    maps.totalFloat.get(activityId),
+    hoursPerDay
+  );
   return {
     criticalPath: {
       earlyStart: toDate(forward?.es),
       earlyFinish: toDate(forward?.ef),
       lateStart: toDate(backward?.ls),
       lateFinish: toDate(backward?.lf),
-      totalSlackHours: totalSlack
+      totalSlackHours
     },
-    isCritical: progress < 100 && totalSlack != null && totalSlack <= 0,
-    freeSlackHours: maps.freeFloat.get(activityId)?.activityFreeFloat ?? null
+    isCritical: progress < 100 && totalSlackHours !== null && totalSlackHours <= 0,
+    freeSlackHours: slackDaysToHours(
+      maps.freeFloat.get(activityId)?.activityFreeFloat,
+      hoursPerDay
+    )
   };
 }
 var datesEqual = (left, right) => left === right || left !== null && right !== null && left.getTime() === right.getTime();
@@ -9653,6 +9987,14 @@ function setCriticalPathFieldsIfChanged(state, activityId, fields) {
   }
   state.setActivityFields(activityId, fields);
 }
+function setCriticalPathLinkFieldsIfChanged(state, linkId, fields) {
+  const link = state.getLink(linkId);
+  if (!link || Object.is(link.freeSlackHours, fields.freeSlackHours) && Object.is(link.isCritical, fields.isCritical)) {
+    return;
+  }
+  state.setLinkField(linkId, "freeSlackHours", fields.freeSlackHours);
+  state.setLinkField(linkId, "isCritical", fields.isCritical);
+}
 async function computeCriticalPathFields(state, hoursPerDay, isCurrent = () => true) {
   if (!isCurrent()) return null;
   const gantt = await createGanttAdapter(state, hoursPerDay);
@@ -9670,37 +10012,34 @@ async function computeCriticalPathFields(state, hoursPerDay, isCurrent = () => t
     totalFloat: criticalPath.totalFloat,
     freeFloat: criticalPath.freeFloat
   };
-  const activityIds = /* @__PURE__ */ new Set([...maps.forward?.keys() ?? []]);
-  const fieldsByActivity = /* @__PURE__ */ new Map();
-  let sinceYield = 0;
-  for (const activityId of activityIds) {
-    if (++sinceYield >= CP_WRITE_YIELD_EVERY) {
-      sinceYield = 0;
-      await yieldToBrowser();
-      if (!isCurrent()) return null;
-    }
-    const activity = state.getActivity(activityId);
-    if (!activity) continue;
-    const progress = Number(activity.progress ?? 0);
-    fieldsByActivity.set(
-      activityId,
-      fieldsForActivity(activityId, progress, maps)
-    );
-  }
-  return isCurrent() ? fieldsByActivity : null;
-}
-async function applyCriticalPath(state, hoursPerDay, isCurrent = () => true) {
-  const fieldsByActivity = await computeCriticalPathFields(
+  const activities = await collectActivityFields(
     state,
+    maps,
     hoursPerDay,
+    gantt.getCanonicalActivityId,
+    isCurrent
+  );
+  if (!activities) return null;
+  const links = await collectLinkFields(
+    state,
+    criticalPath.linkResidualHours,
+    activities,
     isCurrent
   );
-  if (!fieldsByActivity || !isCurrent()) return false;
-  for (const [activityId, fields] of fieldsByActivity) {
+  return links ? { activities, links } : null;
+}
+async function applyCriticalPath(state, hoursPerDay, isCurrent = () => true) {
+  const fields = await computeCriticalPathFields(state, hoursPerDay, isCurrent);
+  if (!fields || !isCurrent()) return false;
+  for (const [activityId, activityFields] of fields.activities) {
     if (!isCurrent()) return false;
-    setCriticalPathFieldsIfChanged(state, activityId, fields);
+    setCriticalPathFieldsIfChanged(state, activityId, activityFields);
   }
-  return true;
+  for (const [linkId, linkFields] of fields.links) {
+    if (!isCurrent()) return false;
+    setCriticalPathLinkFieldsIfChanged(state, linkId, linkFields);
+  }
+  return true;
 }
 
 // src/propagations/upward/real-cost.ts
@@ -9800,9 +10139,15 @@ function isSchedulingDispatch(action, structuralStaleKinds) {
   return true;
 }
 function dispatchChangesSchedulingState(action) {
+  if (action.kind === "activity-lookahead-sync") {
+    return action.persistedProgress !== void 0;
+  }
   return isSchedulingDispatch(action, NO_STRUCTURAL_EXEMPTIONS);
 }
 function resolveRunCriticalPath(action) {
+  if (action.kind === "activity-lookahead-sync") {
+    return action.persistedProgress !== void 0;
+  }
   return isSchedulingDispatch(
     action,
     STRUCTURAL_KINDS_LEAVING_CRITICAL_PATH_STALE
@@ -10088,6 +10433,23 @@ function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
   return effects;
 }
 
+// src/dispatch/conversion.ts
+function snapshotToLink(l) {
+  const view = {
+    id: String(l.id),
+    source: String(l.source),
+    target: String(l.target),
+    type: l.type,
+    lag: Number(l.lag),
+    freeSlackHours: typeof l.freeSlackHours === "number" && Number.isFinite(l.freeSlackHours) ? l.freeSlackHours : null,
+    isCritical: l.isCritical === true
+  };
+  if (l.proplannerId != null) view.proplannerId = Number(l.proplannerId);
+  if (l.ganttId != null) view.ganttId = Number(l.ganttId);
+  if (l.sectorId != null) view.sectorId = Number(l.sectorId);
+  return view;
+}
+
 // src/dispatch/shared/change-set.ts
 async function assembleChangeSet(adapter, args) {
   const allTouched = collectChangeSetIds(adapter, args);
@@ -10097,7 +10459,7 @@ async function assembleChangeSet(adapter, args) {
     const insertedIds = collectInsertedIds(captured);
     mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
-  const sirDetection = args.preview === true ? void 0 : args.sirDetection;
+  const sirDetection = args.sirDetection;
   const beforeDiffEffects = sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
   const correlativeBefore = buildCorrelativeBeforeMap(
     args.correlativeShifts,
@@ -10111,16 +10473,89 @@ async function assembleChangeSet(adapter, args) {
   );
   const effects = sirDetection === "after-diff" ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
   const warnings = args.warnings ?? [];
+  const linkChanges = mergeLinkChanges(
+    args.links ?? [],
+    captured ? buildCapturedCriticalPathLinkChanges(adapter, captured) : []
+  );
   return {
     source: args.source,
     activities: activityChanges,
-    links: args.links ?? [],
+    links: linkChanges,
     calendars: [],
     trackingEvents: args.trackingEvents ?? [],
     ...effects.length > 0 ? { effects } : {},
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+function buildCapturedCriticalPathLinkChanges(adapter, captured) {
+  const changes = [];
+  for (const operation of captured.ops) {
+    if (operation.kind !== "link-field") continue;
+    const after = adapter.getLink(operation.linkId);
+    if (!after) continue;
+    const fields = {};
+    for (const field of ["freeSlackHours", "isCritical"]) {
+      if (!Object.is(operation.before[field], after[field])) {
+        fields[field] = {
+          before: operation.before[field],
+          after: after[field]
+        };
+      }
+    }
+    if (Object.keys(fields).length === 0) continue;
+    changes.push({
+      id: operation.linkId,
+      kind: "updated",
+      fields,
+      after: snapshotToLink(after)
+    });
+  }
+  return changes;
+}
+function mergeLinkChanges(explicit, captured) {
+  const merged = [];
+  const indexById = /* @__PURE__ */ new Map();
+  for (const change of explicit) {
+    const index = indexById.get(change.id);
+    if (index === void 0) {
+      indexById.set(change.id, merged.length);
+      merged.push(change);
+      continue;
+    }
+    const current = merged[index];
+    if ((current.kind === "updated" || current.kind === "created") && change.kind === "updated") {
+      merged[index] = {
+        ...current,
+        fields: { ...current.fields, ...change.fields },
+        after: change.after
+      };
+      continue;
+    }
+    merged[index] = change;
+  }
+  for (const change of captured) {
+    const index = indexById.get(change.id);
+    if (index === void 0) {
+      indexById.set(change.id, merged.length);
+      merged.push(change);
+      continue;
+    }
+    const current = merged[index];
+    if (current.kind === "deleted") continue;
+    const capturedFields = current.kind === "created" ? Object.fromEntries(
+      Object.entries(change.fields ?? {}).map(([field, value]) => [
+        field,
+        { before: void 0, after: value.after }
+      ])
+    ) : change.fields;
+    merged[index] = {
+      ...current,
+      fields: { ...current.fields, ...capturedFields },
+      after: change.after
+    };
+  }
+  return merged;
+}
 function buildCorrelativeBeforeMap(shifts, touched) {
   if (!shifts || shifts.length === 0) return void 0;
   const correlativeBefore = /* @__PURE__ */ new Map();
@@ -10156,21 +10591,6 @@ function collectInsertedIds(captured) {
   );
 }
 
-// src/dispatch/conversion.ts
-function snapshotToLink(l) {
-  const view = {
-    id: String(l.id),
-    source: String(l.source),
-    target: String(l.target),
-    type: l.type,
-    lag: Number(l.lag)
-  };
-  if (l.proplannerId != null) view.proplannerId = Number(l.proplannerId);
-  if (l.ganttId != null) view.ganttId = Number(l.ganttId);
-  if (l.sectorId != null) view.sectorId = Number(l.sectorId);
-  return view;
-}
-
 // src/dispatch/shared/helpers.ts
 function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
   const out = [];
@@ -10438,7 +10858,6 @@ async function dispatchInlineEdit(action, options, deps) {
       touchedIds,
       scheduledIds,
       sirDetection: "before-diff",
-      preview: options.preview,
       links: linkChanges,
       trackingEvents,
       ...constraintWarning ? { warnings: [constraintWarning] } : {},
@@ -10516,6 +10935,26 @@ function collectDeterministicIds(operations) {
   });
   return ids.size > 0 ? ids : void 0;
 }
+function resolveDeterministicIds(deterministicIds, deps) {
+  if (deterministicIds === void 0) return void 0;
+  const resolved = /* @__PURE__ */ new Map();
+  const assigned = /* @__PURE__ */ new Set();
+  const nextAvailableId = () => {
+    let candidate = deps.linkIdGen.next();
+    while (deps.adapter.getLink(candidate) !== null || deps.isLinkIdReserved(String(candidate)) || assigned.has(String(candidate))) {
+      candidate = deps.linkIdGen.next();
+    }
+    return candidate;
+  };
+  for (const [operationIndex, explicitId] of deterministicIds) {
+    const isReserved = deps.adapter.getLink(explicitId) !== null || deps.isLinkIdReserved(String(explicitId)) || assigned.has(String(explicitId));
+    const linkId = isReserved ? nextAvailableId() : explicitId;
+    if (!isReserved) deps.linkIdGen.bump(explicitId);
+    assigned.add(String(linkId));
+    resolved.set(operationIndex, linkId);
+  }
+  return resolved;
+}
 function batchOpToLinkOperation(op, hoursPerDay) {
   if (op.kind === "create") {
     return {
@@ -10548,7 +10987,7 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
     operations,
     adapter,
     linkIdGen,
-    deterministicIds
+    resolveDeterministicIds(deterministicIds, deps)
   );
   if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== "inline-edit") {
     return { ok: false, reason: applied[0].rejected };
@@ -10730,26 +11169,19 @@ function recomputeHhCascadeForParent(startParentId, adapter) {
   if (!startParentId || startParentId === "0") return;
   let currentParentId = String(startParentId);
   while (currentParentId !== null) {
-    const childIds = adapter.getChildren(currentParentId);
-    let hhSum = 0;
-    let rwSum = 0;
-    for (const childId of childIds) {
-      const child = adapter.getActivity(childId);
-      if (!child) continue;
-      const hh = readNumber(child, ACTIVITY_PROPERTY.WORK_HOURS);
-      const rw = readChildRealWork(childId, child, hh, adapter);
-      hhSum += hh;
-      rwSum += rw;
-    }
+    const { workHours, realWorkHours } = computeParentHhRollup(
+      currentParentId,
+      adapter
+    );
     adapter.setActivityField(
       currentParentId,
       ACTIVITY_PROPERTY.WORK_HOURS,
-      hhSum
+      workHours
     );
     adapter.setActivityField(
       currentParentId,
       ACTIVITY_PROPERTY.REAL_WORK_HOURS,
-      rwSum
+      realWorkHours
     );
     const parentSnap = adapter.getActivity(currentParentId);
     if (!parentSnap) break;
@@ -10765,6 +11197,40 @@ function recomputeHhCascadeForActivity(activityId, adapter) {
   if (!parentId || isRootParent(parentId)) return;
   recomputeHhCascadeForParent(parentId, adapter);
 }
+function recomputeRealWorkFromProgress(progressIds, parentIdsDeepestFirst, adapter) {
+  for (const activityId of progressIds) {
+    if (adapter.hasChildren(activityId)) continue;
+    const activity = adapter.getActivity(activityId);
+    if (!activity) continue;
+    adapter.setActivityField(
+      activityId,
+      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
+      computeLeafRealWork(
+        readNumber(activity, ACTIVITY_PROPERTY.WORK_HOURS),
+        readNumber(activity, ACTIVITY_PROPERTY.PROGRESS)
+      )
+    );
+  }
+  for (const parentId of parentIdsDeepestFirst) {
+    adapter.setActivityField(
+      parentId,
+      ACTIVITY_PROPERTY.REAL_WORK_HOURS,
+      computeParentHhRollup(parentId, adapter).realWorkHours
+    );
+  }
+}
+function computeParentHhRollup(parentId, adapter) {
+  let workHours = 0;
+  let realWorkHours = 0;
+  for (const childId of adapter.getChildren(parentId)) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    const childWorkHours = readNumber(child, ACTIVITY_PROPERTY.WORK_HOURS);
+    workHours += childWorkHours;
+    realWorkHours += readChildRealWork(childId, child, childWorkHours, adapter);
+  }
+  return { workHours, realWorkHours };
+}
 function readNumber(activity, key) {
   const v = activity[key];
   if (typeof v === "number" && Number.isFinite(v)) return v;
@@ -11137,6 +11603,36 @@ function computeFractionalCidAtIndex(adapter, parentKey, targetIndex, excludeId)
   return (before + after) / 2;
 }
 
+// src/dispatch/creation-overrides.ts
+var PUBLIC_CREATION_OVERRIDE_FIELDS = /* @__PURE__ */ new Set([
+  ...[...CREATION_OVERRIDE_FIELDS].filter((field) => field !== "durationHours"),
+  "durationDays"
+]);
+function normalizeActivityCreationOverrides(raw, hoursPerDay) {
+  if (raw === void 0) return { ok: true, value: {} };
+  const prototype = Object.getPrototypeOf(raw);
+  if (prototype !== null && prototype !== Object.prototype) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  for (const key of Reflect.ownKeys(raw)) {
+    if (typeof key === "symbol" || !PUBLIC_CREATION_OVERRIDE_FIELDS.has(key)) {
+      return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+    }
+  }
+  const { durationDays, ...rest } = raw;
+  if (durationDays !== void 0 && (!Number.isFinite(durationDays) || durationDays < 0)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  return {
+    ok: true,
+    value: {
+      ...rest,
+      ...durationDays === 0 && (rest.type === void 0 || rest.type === "task") ? { type: "milestone" } : {},
+      ...durationDays === void 0 ? {} : { durationHours: durationToHours(durationDays, hoursPerDay) }
+    }
+  };
+}
+
 // src/dispatch/handlers/activity-create.ts
 async function createActivityCore(action, deps, opts = {}) {
   const { adapter, scheduler, sector, calendars, activityIdGen, uidGen } = deps;
@@ -11144,7 +11640,12 @@ async function createActivityCore(action, deps, opts = {}) {
   const target = validateCreateTarget(action, adapter);
   if (!target.ok) return target;
   const { parent, anchorSiblingId, isRoot } = target;
-  const newId = resolveNewActivityId(action.activityId, adapter, activityIdGen);
+  const newId = resolveNewActivityId(
+    action.activityId,
+    adapter,
+    activityIdGen,
+    deps.isActivityIdReserved
+  );
   const newUid = uidGen.next();
   const activityInput = {
     id: newId,
@@ -11237,9 +11738,18 @@ function validateAnchorSibling(action, adapter, isRoot, anchorSiblingId) {
   }
   return null;
 }
-function resolveNewActivityId(explicitId, adapter, activityIdGen) {
-  if (explicitId === void 0) return activityIdGen.next();
-  if (adapter.activityExists(explicitId)) return activityIdGen.next();
+function resolveNewActivityId(explicitId, adapter, activityIdGen, isActivityIdReserved) {
+  const nextAvailableId = () => {
+    let candidate = activityIdGen.next();
+    while (adapter.activityExists(candidate) || isActivityIdReserved(String(candidate))) {
+      candidate = activityIdGen.next();
+    }
+    return candidate;
+  };
+  if (explicitId === void 0) return nextAvailableId();
+  if (adapter.activityExists(explicitId) || isActivityIdReserved(String(explicitId))) {
+    return nextAvailableId();
+  }
   activityIdGen.bump(explicitId);
   return explicitId;
 }
@@ -11318,7 +11828,15 @@ async function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, h
 }
 async function dispatchActivityCreate(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
-  const core = await createActivityCore(action, deps);
+  const normalized2 = normalizeActivityCreationOverrides(
+    action.overrides,
+    sector.hoursPerDay
+  );
+  if (!normalized2.ok) return normalized2;
+  const core = await createActivityCore(
+    { ...action, overrides: normalized2.value },
+    deps
+  );
   if (!core.ok) return core;
   const { newId } = core;
   const createdAutoScheduling = core.newActivity.autoScheduling;
@@ -11530,7 +12048,7 @@ async function dispatchActivityDelete(action, options, deps) {
   for (const linkId of incidentLinkIds) {
     adapter.removeLink(linkId);
   }
-  const viewStateChanges = captureDeletedViewState(adapter, toDelete);
+  const viewStateChanges2 = captureDeletedViewState(adapter, toDelete);
   let removed = 0;
   for (const id of toDelete) {
     removed += 1;
@@ -11612,7 +12130,6 @@ async function dispatchActivityDelete(action, options, deps) {
     touchedIds,
     scheduledIds,
     sirDetection: "after-diff",
-    preview: options.preview,
     links: buildLinkDeletions(beforeLinks),
     trackingEvents: [trackingEvent],
     hoursPerDay: sector.hoursPerDay,
@@ -11620,7 +12137,7 @@ async function dispatchActivityDelete(action, options, deps) {
   });
   return {
     ok: true,
-    changes: viewStateChanges.length > 0 ? { ...changes, viewState: viewStateChanges } : changes,
+    changes: viewStateChanges2.length > 0 ? { ...changes, viewState: viewStateChanges2 } : changes,
     __beforeSnap: deletedRowsSnap,
     __beforeLinks: beforeLinksByStringId
   };
@@ -11728,7 +12245,7 @@ async function dispatchActivityBatch(action, options, deps) {
       source: link.source,
       target: link.target,
       type: link.type,
-      lag: options.inputUnit === "hours" ? link.lag : lagDaysToHours(link.lag, deps.sector.hoursPerDay)
+      lag: lagDaysToHours(link.lag, deps.sector.hoursPerDay)
     },
     linkId: link.linkId
   }));
@@ -11773,7 +12290,6 @@ async function dispatchActivityBatch(action, options, deps) {
     links: buildLinkChangesForBatch(appliedLinks, beforeLinks, deps.adapter),
     hoursPerDay: deps.sector.hoursPerDay,
     correlativeShifts: existingCorrelativeShifts,
-    preview: options.preview,
     ...action.mode === "replace" ? { sirDetection: "after-diff" } : {}
   });
   return {
@@ -11801,7 +12317,7 @@ function validateBatch(action, deps) {
     }
     if (item.activityId !== void 0) {
       const activityId = String(item.activityId);
-      if (activityId.length === 0 || activityId === "0" || explicitActivityIds.has(activityId) || action.mode === "append" && deps.adapter.getActivity(activityId) !== null) {
+      if (activityId.length === 0 || activityId === "0" || explicitActivityIds.has(activityId)) {
         return REJECTION_REASON.INVALID;
       }
       explicitActivityIds.add(activityId);
@@ -11823,7 +12339,7 @@ function validateBatch(action, deps) {
     }
     if (link.linkId !== void 0) {
       const linkId = String(link.linkId);
-      if (linkId.length === 0 || explicitLinkIds.has(linkId) || action.mode === "append" && deps.adapter.getLink(linkId) !== null) {
+      if (linkId.length === 0 || explicitLinkIds.has(linkId)) {
         return REJECTION_REASON.INVALID;
       }
       explicitLinkIds.add(linkId);
@@ -11859,24 +12375,38 @@ function hasParentCycle(items) {
   return false;
 }
 function buildBatchPlan(action, deps) {
+  const normalizedOverrides = /* @__PURE__ */ new Map();
   for (const item of action.items) {
-    if (item.activityId !== void 0) {
-      deps.activityIdGen.bump(item.activityId);
-    }
+    const normalized2 = normalizeActivityCreationOverrides(
+      item.overrides,
+      deps.sector.hoursPerDay
+    );
+    if (!normalized2.ok) return normalized2;
+    normalizedOverrides.set(item.batchId, normalized2.value);
   }
   const activityIdsByBatchId = /* @__PURE__ */ new Map();
+  const plannedActivityIds = /* @__PURE__ */ new Set();
   for (const item of action.items) {
-    activityIdsByBatchId.set(
-      item.batchId,
-      item.activityId ?? deps.activityIdGen.next()
+    const activityId = resolvePlannedActivityId(
+      item.activityId,
+      action.mode,
+      plannedActivityIds,
+      deps
     );
-  }
-  for (const link of action.links) {
-    if (link.linkId !== void 0) deps.linkIdGen.bump(link.linkId);
-  }
-  const linkIds = action.links.map(
-    (link) => link.linkId ?? deps.linkIdGen.next()
-  );
+    plannedActivityIds.add(String(activityId));
+    activityIdsByBatchId.set(item.batchId, activityId);
+  }
+  const plannedLinkIds = /* @__PURE__ */ new Set();
+  const linkIds = action.links.map((link) => {
+    const linkId = resolvePlannedLinkId(
+      link.linkId,
+      action.mode,
+      plannedLinkIds,
+      deps
+    );
+    plannedLinkIds.add(String(linkId));
+    return linkId;
+  });
   const insertionCorrelativeIds = planInsertionCorrelatives(
     action,
     activityIdsByBatchId,
@@ -11899,7 +12429,8 @@ function buildBatchPlan(action, deps) {
       activityId,
       parentId,
       parentBatchId,
-      insertionCorrelativeId
+      insertionCorrelativeId,
+      overrides: normalizedOverrides.get(item.batchId) ?? {}
     });
   }
   const links = [];
@@ -11920,6 +12451,30 @@ function buildBatchPlan(action, deps) {
   }
   return { ok: true, plan: { items, links } };
 }
+function resolvePlannedActivityId(explicitId, mode, plannedIds, deps) {
+  const explicitIsAvailable = explicitId !== void 0 && (mode === "replace" || deps.adapter.getActivity(explicitId) === null && !deps.isActivityIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
+  if (explicitIsAvailable) {
+    deps.activityIdGen.bump(explicitId);
+    return explicitId;
+  }
+  let candidate = deps.activityIdGen.next();
+  while (plannedIds.has(String(candidate)) || mode === "append" && (deps.adapter.getActivity(candidate) !== null || deps.isActivityIdReserved(String(candidate)))) {
+    candidate = deps.activityIdGen.next();
+  }
+  return candidate;
+}
+function resolvePlannedLinkId(explicitId, mode, plannedIds, deps) {
+  const explicitIsAvailable = explicitId !== void 0 && (mode === "replace" || deps.adapter.getLink(explicitId) === null && !deps.isLinkIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
+  if (explicitIsAvailable) {
+    deps.linkIdGen.bump(explicitId);
+    return explicitId;
+  }
+  let candidate = deps.linkIdGen.next();
+  while (plannedIds.has(String(candidate)) || mode === "append" && (deps.adapter.getLink(candidate) !== null || deps.isLinkIdReserved(String(candidate)))) {
+    candidate = deps.linkIdGen.next();
+  }
+  return candidate;
+}
 function planInsertionCorrelatives(action, activityIdsByBatchId, deps) {
   if (isSimpleRootAppend(action)) {
     const firstCorrelativeId = deps.adapter.activityCount();
@@ -12029,7 +12584,7 @@ async function createPlannedActivities(action, plannedItems, deps) {
       {
         parentId: item.parentId,
         activityId: item.activityId,
-        ...item.input.overrides === void 0 ? {} : { overrides: item.input.overrides },
+        overrides: item.overrides,
         ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
       },
       deps,
@@ -12106,301 +12661,280 @@ function dispatchSirSync(action, deps) {
   };
 }
 
-// src/dispatch/handlers/bulk-edit.ts
-var CUSTOM_ID_COLUMN = COLUMN.CUSTOM_ID;
-async function dispatchBulkEdit(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  const editsIncludeDuration = action.edits.some(
-    (edit) => edit.column === COLUMN.DURATION
+// src/propagations/upward/progress-rollup.ts
+function recomputeAllProgressRollup(adapter) {
+  for (const parentId of parentsDeepestFirst(adapter)) {
+    rollupParent(parentId, adapter);
+  }
+}
+function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
+  for (const parentId of parentIdsDeepestFirst) {
+    rollupParent(parentId, adapter);
+  }
+}
+function parentsDeepestFirst(adapter) {
+  const parents = /* @__PURE__ */ new Set();
+  adapter.forEachActivity((_activity, id) => {
+    if (adapter.getChildren(id).length > 0) parents.add(id);
+  });
+  const depthById = /* @__PURE__ */ new Map();
+  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
+  return [...parents].sort(
+    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
   );
-  if (editsIncludeDuration) {
-    scheduler.invalidateExpandedLinksCache();
+}
+function depthOf2(id, adapter) {
+  let depth = 0;
+  let current = id;
+  while (current && current !== "0") {
+    if (!adapter.getActivity(current)) break;
+    depth += 1;
+    current = adapter.getParentId(current);
   }
-  const verdicts = [];
-  const beforeSnap = /* @__PURE__ */ new Map();
-  const constraintPriorsByActivity = /* @__PURE__ */ new Map();
-  const explicitDateEditActivities = /* @__PURE__ */ new Set();
-  const touchedIds = /* @__PURE__ */ new Set();
-  const trackingEvents = [];
-  const linkChanges = [];
-  const warnings = [];
-  let needsAutoSchedule = false;
-  for (const edit of action.edits) {
-    const outcome = applyOneEdit(edit, deps);
-    verdicts.push(outcome.verdict);
-    if (!outcome.verdict.ok || !outcome.changes) continue;
-    const constraintWarning = toConstraintWarning(
-      edit.activityId,
-      outcome.changes.constraintWarning
+  return depth;
+}
+function rollupParent(parentId, adapter) {
+  const childIds = adapter.getChildren(parentId);
+  if (childIds.length === 0) return;
+  const children = [];
+  for (const childId of childIds) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    children.push({
+      progress: Number(child.progress ?? 0),
+      ponderator: Number(child.ponderator ?? 0)
+    });
+  }
+  const rollup = computeWeightedProgressRollup(children);
+  if (rollup !== null) {
+    adapter.setActivityField(
+      parentId,
+      COLUMN.PROGRESS,
+      roundProgressPerLevel(rollup)
     );
-    if (constraintWarning) warnings.push(constraintWarning);
-    const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
-    mergeBeforeSnapshots(beforeSnap, editTouched, deps);
-    for (const touchedId of editTouched) touchedIds.add(touchedId);
-    recordConstraintPrior(constraintPriorsByActivity, edit, beforeSnap);
-    if (isExplicitConstraintDateEdit(edit.column)) {
-      explicitDateEditActivities.add(String(edit.activityId));
+  }
+}
+
+// src/dispatch/handlers/persistence-acknowledge.ts
+function persistedOwnersOf(entities) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    const proplannerId = entity.proplannerId;
+    if (typeof proplannerId === "number" && Number.isSafeInteger(proplannerId) && proplannerId > 0) {
+      owners.set(proplannerId, String(entity.id));
     }
-    const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
-    const preEditSnapshot = snapshotSingleActivity(
-      adapter,
-      String(edit.activityId)
+  }
+  return owners;
+}
+function assertAllNewEntitiesAcknowledged(entities, assignments, entityName) {
+  const acknowledgedIds = new Set(assignments.map(({ id }) => String(id)));
+  for (const entity of entities) {
+    if ((entity.proplannerId == null || entity.proplannerId === 0) && !acknowledgedIds.has(String(entity.id))) {
+      throw new Error(
+        `persistence-acknowledge: missing ${entityName} proplannerId for "${String(entity.id)}"`
+      );
+    }
+  }
+}
+function assertValidAssignment(assignment, entityName, readCurrent, ownerByBackendId, seenIds, seenBackendIds) {
+  const id = String(assignment.id);
+  if (id.length === 0 || seenIds.has(id)) {
+    throw new Error(
+      `persistence-acknowledge: duplicate or empty ${entityName} id "${id}"`
     );
-    const customIdBeforeApply = readLiveCustomId(edit, deps);
-    const changes = outcome.changes;
-    applyFieldChanges(adapter, edit.activityId, changes);
-    runPostProcessorsOnAdapter(
-      edit.activityId,
-      outcome.changes.postProcessors ?? [],
-      adapter,
-      preEditSnapshot
+  }
+  if (!Number.isSafeInteger(assignment.proplannerId) || assignment.proplannerId <= 0) {
+    throw new Error(
+      `persistence-acknowledge: invalid ${entityName} proplannerId ${String(assignment.proplannerId)}`
     );
-    syncCustomIdTracker(edit, customIdBeforeApply, deps);
-    linkChanges.push(
-      ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
+  }
+  if (seenBackendIds.has(assignment.proplannerId)) {
+    throw new Error(
+      `persistence-acknowledge: duplicate ${entityName} proplannerId ${String(assignment.proplannerId)}`
     );
-    needsAutoSchedule ||= Boolean(outcome.changes.needsAutoSchedule);
-    for (const trackingEvent of outcome.changes.trackingEvents ?? []) {
-      trackingEvents.push({
-        name: trackingEvent.name,
-        properties: trackingEvent.properties ?? {}
-      });
-    }
   }
-  const postMutationArgs = {
-    action,
-    autoscheduleFrom: needsAutoSchedule ? "roots" : null,
-    recomputeParentsFrom: touchedIds,
-    now: deps.now,
-    options
-  };
-  const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
-  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
-    {
-      adapter,
-      scheduler,
-      sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    {
-      postMutationArgs,
-      revertTargets: [...constraintPriorsByActivity].filter(
-        ([activityId]) => !explicitDateEditActivities.has(activityId)
-      ).map(([activityId, priorConstraintDate]) => ({
-        activityId,
-        priorConstraintDate
-      })),
-      revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
-        activityId,
-        priorConstraintDate,
-        adapter,
-        deps.ctx.calendars
-      )
-    }
-  ) : runPostMutation(
-    {
-      adapter,
-      scheduler,
-      sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    postMutationArgs
-  ));
-  return {
-    ok: true,
-    verdicts,
-    changes: await assembleChangeSet(adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds,
-      scheduledIds,
-      sirDetection: "before-diff",
-      preview: options.preview,
-      links: linkChanges,
-      trackingEvents,
-      warnings,
-      hoursPerDay: sector.hoursPerDay
-    })
-  };
-}
-function applyOneEdit(edit, deps) {
-  const { ctx } = deps;
-  const activityId = edit.activityId;
-  const pipeline = findPipelineForColumn(edit.column);
-  if (!pipeline) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN
-      },
-      changes: null
-    };
-  }
-  const activitySnap = ctx.activityReader.getActivity(edit.activityId);
-  if (!activitySnap) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
-      },
-      changes: null
-    };
-  }
-  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
-  if (!editGate.allowed) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: editGate.reason ?? REJECTION_REASON.CANNOT_EDIT,
-        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
-      },
-      changes: null
-    };
-  }
-  const parsed2 = pipeline.parseInput(edit.newValue, activitySnap, ctx);
-  if (!parsed2.ok) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: parsed2.reason ?? REJECTION_REASON.PARSE_ERROR
-      },
-      changes: null
-    };
+  const state = readCurrent(id);
+  if (!state.exists) {
+    throw new Error(
+      `persistence-acknowledge: unknown ${entityName} id "${id}"`
+    );
   }
-  const oldValue = Reflect.get(activitySnap, pipeline.targetField);
-  const validation = pipeline.validate(
-    activitySnap,
-    oldValue,
-    parsed2.value,
-    ctx
-  );
-  if (!validation.valid) {
-    return {
-      verdict: {
-        activityId,
-        ok: false,
-        reason: validation.reason ?? REJECTION_REASON.INVALID,
-        ...validation.notification?.messageKey ? { alertKey: validation.notification.messageKey } : {}
-      },
-      changes: null
-    };
+  if (state.current !== null && state.current !== 0 && state.current !== assignment.proplannerId) {
+    throw new Error(
+      `persistence-acknowledge: ${entityName} "${id}" already has proplannerId ${String(state.current)}`
+    );
   }
-  if (edit.column === CUSTOM_ID_COLUMN && parsed2.value !== null) {
-    const liveActivity = deps.adapter.getActivity(edit.activityId);
-    const oldCustomIdRaw = liveActivity ? liveActivity.customId : null;
-    const oldCustomId = typeof oldCustomIdRaw === "string" ? oldCustomIdRaw : null;
-    if (deps.customIdTracker.isCustomIdInUse(String(parsed2.value), oldCustomId)) {
-      return {
-        verdict: {
-          activityId,
-          ok: false,
-          reason: REJECTION_REASON.CUSTOM_ID_DUPLICATE
-        },
-        changes: null
-      };
-    }
+  const existingOwner = ownerByBackendId.get(assignment.proplannerId);
+  if (existingOwner !== void 0 && existingOwner !== id) {
+    throw new Error(
+      `persistence-acknowledge: ${entityName} proplannerId ${String(assignment.proplannerId)} already belongs to "${existingOwner}"`
+    );
   }
-  const changes = pipeline.transform(
-    activitySnap,
-    parsed2.value,
-    ctx,
-    parsed2.raw
-  );
-  return { verdict: { activityId, ok: true }, changes };
-}
-function readLiveCustomId(edit, deps) {
-  if (edit.column !== CUSTOM_ID_COLUMN) return null;
-  const liveActivity = deps.adapter.getActivity(edit.activityId);
-  const rawValue = liveActivity ? liveActivity.customId : null;
-  return typeof rawValue === "string" ? rawValue : null;
+  seenIds.add(id);
+  seenBackendIds.add(assignment.proplannerId);
 }
-function syncCustomIdTracker(edit, oldCustomId, deps) {
-  if (edit.column !== CUSTOM_ID_COLUMN) return;
-  const liveActivity = deps.adapter.getActivity(edit.activityId);
-  const rawValue = liveActivity ? liveActivity.customId : null;
-  const newCustomId = typeof rawValue === "string" ? rawValue : null;
-  if (oldCustomId !== newCustomId) {
-    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
+function assertValidAssignments(assignments, entityName, readCurrent, ownerByBackendId) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenBackendIds = /* @__PURE__ */ new Set();
+  for (const assignment of assignments) {
+    assertValidAssignment(
+      assignment,
+      entityName,
+      readCurrent,
+      ownerByBackendId,
+      seenIds,
+      seenBackendIds
+    );
   }
 }
-function recordConstraintPrior(priors, edit, beforeSnap) {
-  if (!isConstraintEditColumn(edit.column)) return;
-  const activityKey = String(edit.activityId);
-  if (priors.has(activityKey)) return;
-  const preBatchSnapshot = beforeSnap.get(activityKey);
-  if (!preBatchSnapshot) return;
-  priors.set(activityKey, preBatchSnapshot.constraintDate ?? null);
-}
-function mergeBeforeSnapshots(beforeSnap, ids, deps) {
-  const missing = /* @__PURE__ */ new Set();
-  for (const candidateId of ids) {
-    if (!beforeSnap.has(candidateId)) missing.add(candidateId);
-  }
-  if (missing.size === 0) return;
-  for (const missingId of missing) {
-    const liveActivity = deps.adapter.getActivity(missingId);
-    if (liveActivity) {
-      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
+function assertValidReconciledProgress(entries, deps) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const id = String(entry.activityId);
+    if (id.length === 0 || seen.has(id)) {
+      throw new Error(
+        `persistence-acknowledge: duplicate or empty reconciled activity id "${id}"`
+      );
+    }
+    if (!Number.isFinite(entry.progress) || entry.progress < 0 || entry.progress > 100) {
+      throw new Error(
+        `persistence-acknowledge: invalid reconciled progress ${String(entry.progress)} for "${id}"`
+      );
+    }
+    if (!deps.adapter.getActivity(id)) {
+      throw new Error(
+        `persistence-acknowledge: unknown reconciled activity id "${id}"`
+      );
     }
+    seen.add(id);
   }
 }
-
-// src/dispatch/handlers/sir-approve.ts
-async function dispatchSirApprove(action, options, deps) {
-  const { adapter } = deps;
-  const snapshot = adapter.getActivity(action.activityId);
-  if (!snapshot) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
-  }
-  const pending = snapshot.pendingRequestIds ?? [];
-  if (!pending.includes(action.approvedRequestId)) {
-    return { ok: false, reason: REJECTION_REASON.SIR_REQUEST_NOT_PENDING };
+async function applyReconciledProgress(entries, deps) {
+  const progressToApply = entries.filter((entry) => {
+    const current = deps.adapter.getActivity(String(entry.activityId));
+    return current !== null && current.progress !== entry.progress;
+  });
+  const progressIds = new Set(
+    progressToApply.map((entry) => String(entry.activityId))
+  );
+  const ancestors = findAncestorsOfDirty(deps.adapter, progressIds);
+  const touched = new Set(progressIds);
+  for (const parentId of ancestors) {
+    touched.add(String(parentId));
   }
-  const remaining = pending.filter((id) => id !== action.approvedRequestId);
-  adapter.setActivityField(action.activityId, "pendingRequestIds", remaining);
-  const result = await dispatchBulkEdit(
-    {
-      kind: "bulk-edit",
-      edits: [
-        {
-          activityId: action.activityId,
-          column: COLUMN.START_DATE,
-          newValue: action.startDate
-        },
-        {
-          activityId: action.activityId,
-          column: COLUMN.END_DATE,
-          newValue: action.endDate
-        },
-        // asap ÚLTIMO: gana al SNET implícito (paridad legacy).
-        {
-          activityId: action.activityId,
-          column: COLUMN.CONSTRAINT_TYPE,
-          newValue: "asap"
-        }
-      ],
-      eventSource: action.eventSource
+  const before = await snapshotActivities(deps.adapter, touched);
+  deps.adapter.batchUpdate(() => {
+    for (const entry of progressToApply) {
+      deps.adapter.setActivityField(
+        String(entry.activityId),
+        "progress",
+        entry.progress
+      );
+    }
+    recomputeProgressRollupForParents(ancestors, deps.adapter);
+    recomputeRealWorkFromProgress(progressIds, ancestors, deps.adapter);
+  });
+  return [...await buildActivityChanges(deps.adapter, before, touched)];
+}
+async function dispatchPersistenceAcknowledge(action, deps) {
+  const activities = action.activities ?? [];
+  const links = action.links ?? [];
+  const reconciledProgress = action.reconciledProgress ?? [];
+  assertValidReconciledProgress(reconciledProgress, deps);
+  const currentActivities = deps.adapter.getAllActivities();
+  const currentLinks = deps.adapter.getAllLinks();
+  const activityOwnerByBackendId = persistedOwnersOf(currentActivities);
+  const linkOwnerByBackendId = persistedOwnersOf(currentLinks);
+  assertValidAssignments(
+    activities,
+    "activity",
+    (id) => {
+      const activity = deps.adapter.getActivity(id);
+      return {
+        exists: activity !== null,
+        current: activity?.proplannerId ?? null
+      };
     },
-    options,
+    activityOwnerByBackendId
+  );
+  assertValidAssignments(
+    links,
+    "link",
+    (id) => {
+      const link = deps.adapter.getLink(id);
+      return { exists: link !== null, current: link?.proplannerId ?? null };
+    },
+    linkOwnerByBackendId
+  );
+  assertAllNewEntitiesAcknowledged(currentActivities, activities, "activity");
+  assertAllNewEntitiesAcknowledged(currentLinks, links, "link");
+  const activityChanges = await applyReconciledProgress(
+    reconciledProgress,
     deps
   );
-  if (!result.ok) return result;
-  const hardFailure = "verdicts" in result ? result.verdicts.find(
-    (verdict) => !verdict.ok && verdict.reason !== VALIDATION_REASON.UNCHANGED
-  ) : void 0;
-  if (hardFailure) {
-    return { ok: false, reason: hardFailure.reason };
-  }
-  return { ...result, changes: { ...result.changes, source: action } };
+  const linkChanges = [];
+  deps.adapter.batchUpdate(() => {
+    for (const assignment of activities) {
+      const before = deps.adapter.getActivity(assignment.id);
+      if (!before || before.proplannerId === assignment.proplannerId) continue;
+      const previousProplannerId = before.proplannerId;
+      deps.adapter.setActivityField(
+        assignment.id,
+        "proplannerId",
+        assignment.proplannerId
+      );
+      activityChanges.push({
+        id: assignment.id,
+        kind: "updated",
+        fields: {
+          proplannerId: {
+            before: previousProplannerId,
+            after: assignment.proplannerId
+          }
+        },
+        after: { ...before, proplannerId: assignment.proplannerId }
+      });
+    }
+    for (const assignment of links) {
+      const before = deps.adapter.getLink(assignment.id);
+      if (!before || before.proplannerId === assignment.proplannerId) continue;
+      const previousProplannerId = before.proplannerId;
+      deps.adapter.setLinkProplannerId(assignment.id, assignment.proplannerId);
+      linkChanges.push({
+        id: assignment.id,
+        kind: "updated",
+        fields: {
+          proplannerId: {
+            before: previousProplannerId,
+            after: assignment.proplannerId
+          }
+        },
+        after: { ...before, proplannerId: assignment.proplannerId }
+      });
+    }
+  });
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: activityChanges,
+      links: linkChanges,
+      calendars: [],
+      trackingEvents: []
+    }
+  };
 }
 
 // src/dispatch/handlers/activity-lookahead-sync.ts
-function dispatchActivityLookaheadSync(action, deps) {
+async function dispatchActivityLookaheadSync(action, options, deps) {
+  if (hasInvalidPersistedProgress(action)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
   const ids = [...new Set(action.activityIds.map(String))];
+  const acknowledgesUnknownPersistedActivity = action.acknowledgePersistedLookahead === true && ids.some((activityId) => !deps.isActivityIdReserved(activityId));
+  if (acknowledgesUnknownPersistedActivity) {
+    return { ok: false, reason: REJECTION_REASON.INVALID };
+  }
   const snapshots = ids.map((id) => deps.adapter.getActivity(id));
   if (snapshots.some((snapshot) => !snapshot)) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
@@ -12440,6 +12974,39 @@ function dispatchActivityLookaheadSync(action, deps) {
       }
     });
   }
+  if (action.persistedProgress !== void 0) {
+    const progressChanges = await applyReconciledProgress(
+      [{ activityId: ids[0], progress: action.persistedProgress }],
+      deps
+    );
+    if (progressChanges.length > 0) {
+      await runPostMutation(
+        {
+          adapter: deps.adapter,
+          scheduler: deps.scheduler,
+          sector: deps.sector,
+          defaultBaseCalendarId: deps.defaultBaseCalendarId
+        },
+        {
+          action,
+          autoscheduleFrom: null,
+          recomputeParentsFrom: [],
+          now: deps.now,
+          options
+        }
+      );
+      return {
+        ok: true,
+        changes: await assembleChangeSet(deps.adapter, {
+          source: action,
+          beforeSnap: /* @__PURE__ */ new Map(),
+          touchedIds: [],
+          scheduledIds: [],
+          hoursPerDay: deps.sector.hoursPerDay
+        })
+      };
+    }
+  }
   return {
     ok: true,
     changes: {
@@ -12451,6 +13018,10 @@ function dispatchActivityLookaheadSync(action, deps) {
     }
   };
 }
+function hasInvalidPersistedProgress(action) {
+  const progress = action.persistedProgress;
+  return progress !== void 0 && (action.activityIds.length !== 1 || !Number.isFinite(progress) || progress < 0 || progress > 100);
+}
 
 // src/internal/hierarchy/invalid-links.ts
 function collectInvalidLinkIdsForCycle(movedActivityIds, adapter) {
@@ -12718,7 +13289,6 @@ async function dispatchActivityMove(action, options, deps) {
       touchedIds: touched,
       scheduledIds,
       sirDetection: "before-diff",
-      preview: options.preview,
       trackingEvents: [trackingEvent],
       hoursPerDay: sector.hoursPerDay
     })
@@ -13216,44 +13786,205 @@ async function dispatchActivitySetProgress(action, options, deps) {
     changes.postProcessors ?? [],
     adapter
   );
-  const { scheduledIds } = await runPostMutation(
-    {
-      adapter,
-      scheduler,
-      sector: deps.sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    {
-      action,
-      autoscheduleFrom: changes.needsAutoSchedule ? action.activityId : null,
-      recomputeParentsFrom: [],
-      collectDirty: (sids) => collectDirtyForInlineEdit(action.activityId, touchedIds, sids),
-      now: deps.now,
-      options
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: changes.needsAutoSchedule ? action.activityId : null,
+      recomputeParentsFrom: [],
+      collectDirty: (sids) => collectDirtyForInlineEdit(action.activityId, touchedIds, sids),
+      now: deps.now,
+      options
+    }
+  );
+  const trackingEvents = (changes.trackingEvents ?? []).map((e) => ({
+    name: e.name,
+    properties: e.properties ?? {}
+  }));
+  return {
+    ok: true,
+    changes: await assembleChangeSet(adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds,
+      scheduledIds,
+      trackingEvents,
+      hoursPerDay: sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/handlers/dates-batch.ts
+async function dispatchDatesBatch(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  const verdicts = [];
+  const beforeSnap = /* @__PURE__ */ new Map();
+  const touchedIds = /* @__PURE__ */ new Set();
+  const trackingEvents = [];
+  const linkChanges = [];
+  const warnings = [];
+  let needsAutoSchedule = false;
+  for (const edit of action.edits) {
+    const outcome = applyOneEdit(edit, deps);
+    verdicts.push(outcome.verdict);
+    if (!outcome.verdict.ok || !outcome.changes) continue;
+    const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
+    mergeBeforeSnapshots(beforeSnap, editTouched, deps);
+    for (const id of editTouched) touchedIds.add(id);
+    const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
+    const preEditSnapshot = snapshotSingleActivity(
+      adapter,
+      String(edit.activityId)
+    );
+    applyFieldChanges(adapter, edit.activityId, outcome.changes);
+    runPostProcessorsOnAdapter(
+      edit.activityId,
+      outcome.changes.postProcessors ?? [],
+      adapter,
+      preEditSnapshot
+    );
+    linkChanges.push(
+      ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
+    );
+    needsAutoSchedule ||= Boolean(outcome.changes.needsAutoSchedule);
+    for (const e of outcome.changes.trackingEvents ?? []) {
+      trackingEvents.push({
+        name: e.name,
+        properties: e.properties ?? {}
+      });
+    }
+    const constraintWarning = toConstraintWarning(
+      edit.activityId,
+      outcome.changes.constraintWarning
+    );
+    if (constraintWarning) warnings.push(constraintWarning);
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: needsAutoSchedule ? "roots" : null,
+      recomputeParentsFrom: touchedIds,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    verdicts,
+    changes: await assembleChangeSet(adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds,
+      scheduledIds,
+      sirDetection: "before-diff",
+      links: linkChanges,
+      trackingEvents,
+      warnings,
+      hoursPerDay: sector.hoursPerDay
+    })
+  };
+}
+function applyOneEdit(edit, deps) {
+  const { ctx } = deps;
+  const activityId = edit.activityId;
+  const pipeline = findPipelineForColumn(edit.column);
+  if (!pipeline) {
+    throw new Error(
+      `[ScheduleCore] no pipeline registered for column "${edit.column}"`
+    );
+  }
+  const activitySnap = ctx.activityReader.getActivity(edit.activityId);
+  if (!activitySnap) {
+    throw new Error(`[ScheduleCore] activity "${edit.activityId}" not found`);
+  }
+  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
+  if (!editGate.allowed) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: editGate.reason ?? REJECTION_REASON.CANNOT_EDIT,
+        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
+      },
+      changes: null
+    };
+  }
+  const parsed2 = pipeline.parseInput(edit.newValue, activitySnap, ctx);
+  if (!parsed2.ok) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: parsed2.reason ?? REJECTION_REASON.PARSE_ERROR
+      },
+      changes: null
+    };
+  }
+  const oldValue = Reflect.get(activitySnap, pipeline.targetField);
+  const validation = pipeline.validate(
+    activitySnap,
+    oldValue,
+    parsed2.value,
+    ctx
+  );
+  if (!validation.valid) {
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: validation.reason ?? REJECTION_REASON.INVALID,
+        ...validation.notification?.messageKey ? { alertKey: validation.notification.messageKey } : {}
+      },
+      changes: null
+    };
+  }
+  const changes = pipeline.transform(
+    activitySnap,
+    parsed2.value,
+    ctx,
+    parsed2.raw
+  );
+  return { verdict: { activityId, ok: true }, changes };
+}
+function mergeBeforeSnapshots(beforeSnap, ids, deps) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!beforeSnap.has(id)) missing.add(id);
+  }
+  if (missing.size === 0) return;
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
     }
-  );
-  const trackingEvents = (changes.trackingEvents ?? []).map((e) => ({
-    name: e.name,
-    properties: e.properties ?? {}
-  }));
-  return {
-    ok: true,
-    changes: await assembleChangeSet(adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds,
-      scheduledIds,
-      trackingEvents,
-      hoursPerDay: sector.hoursPerDay
-    })
-  };
+  }
 }
 
-// src/dispatch/handlers/dates-batch.ts
-async function dispatchDatesBatch(action, options, deps) {
+// src/dispatch/handlers/bulk-edit.ts
+var CUSTOM_ID_COLUMN = COLUMN.CUSTOM_ID;
+async function dispatchBulkEdit(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
+  const editsIncludeDuration = action.edits.some(
+    (edit) => edit.column === COLUMN.DURATION
+  );
+  if (editsIncludeDuration) {
+    scheduler.invalidateExpandedLinksCache();
+  }
   const verdicts = [];
   const beforeSnap = /* @__PURE__ */ new Map();
+  const constraintPriorsByActivity = /* @__PURE__ */ new Map();
+  const explicitDateEditActivities = /* @__PURE__ */ new Set();
   const touchedIds = /* @__PURE__ */ new Set();
   const trackingEvents = [];
   const linkChanges = [];
@@ -13263,52 +13994,83 @@ async function dispatchDatesBatch(action, options, deps) {
     const outcome = applyOneEdit2(edit, deps);
     verdicts.push(outcome.verdict);
     if (!outcome.verdict.ok || !outcome.changes) continue;
+    const constraintWarning = toConstraintWarning(
+      edit.activityId,
+      outcome.changes.constraintWarning
+    );
+    if (constraintWarning) warnings.push(constraintWarning);
     const editTouched = collectTouchedIds(edit.activityId, outcome.changes);
     mergeBeforeSnapshots2(beforeSnap, editTouched, deps);
-    for (const id of editTouched) touchedIds.add(id);
+    for (const touchedId of editTouched) touchedIds.add(touchedId);
+    recordConstraintPrior(constraintPriorsByActivity, edit, beforeSnap);
+    if (isExplicitConstraintDateEdit(edit.column)) {
+      explicitDateEditActivities.add(String(edit.activityId));
+    }
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
     const preEditSnapshot = snapshotSingleActivity(
       adapter,
       String(edit.activityId)
     );
-    applyFieldChanges(adapter, edit.activityId, outcome.changes);
+    const customIdBeforeApply = readLiveCustomId(edit, deps);
+    const changes = outcome.changes;
+    applyFieldChanges(adapter, edit.activityId, changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
       outcome.changes.postProcessors ?? [],
       adapter,
       preEditSnapshot
     );
+    syncCustomIdTracker(edit, customIdBeforeApply, deps);
     linkChanges.push(
       ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
     );
     needsAutoSchedule ||= Boolean(outcome.changes.needsAutoSchedule);
-    for (const e of outcome.changes.trackingEvents ?? []) {
+    for (const trackingEvent of outcome.changes.trackingEvents ?? []) {
       trackingEvents.push({
-        name: e.name,
-        properties: e.properties ?? {}
+        name: trackingEvent.name,
+        properties: trackingEvent.properties ?? {}
       });
     }
-    const constraintWarning = toConstraintWarning(
-      edit.activityId,
-      outcome.changes.constraintWarning
-    );
-    if (constraintWarning) warnings.push(constraintWarning);
   }
-  const { scheduledIds } = await runPostMutation(
+  const postMutationArgs = {
+    action,
+    autoscheduleFrom: needsAutoSchedule ? "roots" : null,
+    recomputeParentsFrom: touchedIds,
+    now: deps.now,
+    options
+  };
+  const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
+  const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
     {
       adapter,
       scheduler,
-      sector: deps.sector,
+      sector,
       defaultBaseCalendarId: deps.defaultBaseCalendarId
     },
     {
-      action,
-      autoscheduleFrom: needsAutoSchedule ? "roots" : null,
-      recomputeParentsFrom: touchedIds,
-      now: deps.now,
-      options
+      postMutationArgs,
+      revertTargets: [...constraintPriorsByActivity].filter(
+        ([activityId]) => !explicitDateEditActivities.has(activityId)
+      ).map(([activityId, priorConstraintDate]) => ({
+        activityId,
+        priorConstraintDate
+      })),
+      revert: (activityId, priorConstraintDate) => revertNoOpConstraintEdit(
+        activityId,
+        priorConstraintDate,
+        adapter,
+        deps.ctx.calendars
+      )
     }
-  );
+  ) : runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    postMutationArgs
+  ));
   return {
     ok: true,
     verdicts,
@@ -13318,7 +14080,6 @@ async function dispatchDatesBatch(action, options, deps) {
       touchedIds,
       scheduledIds,
       sirDetection: "before-diff",
-      preview: options.preview,
       links: linkChanges,
       trackingEvents,
       warnings,
@@ -13331,13 +14092,25 @@ function applyOneEdit2(edit, deps) {
   const activityId = edit.activityId;
   const pipeline = findPipelineForColumn(edit.column);
   if (!pipeline) {
-    throw new Error(
-      `[ScheduleCore] no pipeline registered for column "${edit.column}"`
-    );
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN
+      },
+      changes: null
+    };
   }
   const activitySnap = ctx.activityReader.getActivity(edit.activityId);
   if (!activitySnap) {
-    throw new Error(`[ScheduleCore] activity "${edit.activityId}" not found`);
+    return {
+      verdict: {
+        activityId,
+        ok: false,
+        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
+      },
+      changes: null
+    };
   }
   const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
   if (!editGate.allowed) {
@@ -13380,6 +14153,21 @@ function applyOneEdit2(edit, deps) {
       changes: null
     };
   }
+  if (edit.column === CUSTOM_ID_COLUMN && parsed2.value !== null) {
+    const liveActivity = deps.adapter.getActivity(edit.activityId);
+    const oldCustomIdRaw = liveActivity ? liveActivity.customId : null;
+    const oldCustomId = typeof oldCustomIdRaw === "string" ? oldCustomIdRaw : null;
+    if (deps.customIdTracker.isCustomIdInUse(String(parsed2.value), oldCustomId)) {
+      return {
+        verdict: {
+          activityId,
+          ok: false,
+          reason: REJECTION_REASON.CUSTOM_ID_DUPLICATE
+        },
+        changes: null
+      };
+    }
+  }
   const changes = pipeline.transform(
     activitySnap,
     parsed2.value,
@@ -13388,226 +14176,41 @@ function applyOneEdit2(edit, deps) {
   );
   return { verdict: { activityId, ok: true }, changes };
 }
-function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
-  const missing = /* @__PURE__ */ new Set();
-  for (const id of ids) {
-    if (!beforeSnap.has(id)) missing.add(id);
-  }
-  if (missing.size === 0) return;
-  for (const missingId of missing) {
-    const liveActivity = deps.adapter.getActivity(missingId);
-    if (liveActivity) {
-      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
-    }
-  }
-}
-
-// src/dispatch/handlers/persistence-acknowledge.ts
-function assertValidAssignment(assignment, entityName, readCurrent, ownerByBackendId, seenIds, seenBackendIds) {
-  const id = String(assignment.id);
-  if (id.length === 0 || seenIds.has(id)) {
-    throw new Error(
-      `persistence-acknowledge: duplicate or empty ${entityName} id "${id}"`
-    );
-  }
-  if (!Number.isSafeInteger(assignment.proplannerId) || assignment.proplannerId <= 0) {
-    throw new Error(
-      `persistence-acknowledge: invalid ${entityName} proplannerId ${String(assignment.proplannerId)}`
-    );
-  }
-  if (seenBackendIds.has(assignment.proplannerId)) {
-    throw new Error(
-      `persistence-acknowledge: duplicate ${entityName} proplannerId ${String(assignment.proplannerId)}`
-    );
-  }
-  const state = readCurrent(id);
-  if (!state.exists) {
-    throw new Error(
-      `persistence-acknowledge: unknown ${entityName} id "${id}"`
-    );
-  }
-  if (state.current !== null && state.current !== assignment.proplannerId) {
-    throw new Error(
-      `persistence-acknowledge: ${entityName} "${id}" already has proplannerId ${String(state.current)}`
-    );
-  }
-  const existingOwner = ownerByBackendId.get(assignment.proplannerId);
-  if (existingOwner !== void 0 && existingOwner !== id) {
-    throw new Error(
-      `persistence-acknowledge: ${entityName} proplannerId ${String(assignment.proplannerId)} already belongs to "${existingOwner}"`
-    );
-  }
-  seenIds.add(id);
-  seenBackendIds.add(assignment.proplannerId);
-}
-function assertValidAssignments(assignments, entityName, readCurrent, ownerByBackendId) {
-  const seenIds = /* @__PURE__ */ new Set();
-  const seenBackendIds = /* @__PURE__ */ new Set();
-  for (const assignment of assignments) {
-    assertValidAssignment(
-      assignment,
-      entityName,
-      readCurrent,
-      ownerByBackendId,
-      seenIds,
-      seenBackendIds
-    );
-  }
+function readLiveCustomId(edit, deps) {
+  if (edit.column !== CUSTOM_ID_COLUMN) return null;
+  const liveActivity = deps.adapter.getActivity(edit.activityId);
+  const rawValue = liveActivity ? liveActivity.customId : null;
+  return typeof rawValue === "string" ? rawValue : null;
 }
-function assertValidReconciledProgress(entries, deps) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const id = String(entry.activityId);
-    if (id.length === 0 || seen.has(id)) {
-      throw new Error(
-        `persistence-acknowledge: duplicate or empty reconciled activity id "${id}"`
-      );
-    }
-    if (!Number.isFinite(entry.progress) || entry.progress < 0 || entry.progress > 100) {
-      throw new Error(
-        `persistence-acknowledge: invalid reconciled progress ${String(entry.progress)} for "${id}"`
-      );
-    }
-    if (!deps.adapter.getActivity(id)) {
-      throw new Error(
-        `persistence-acknowledge: unknown reconciled activity id "${id}"`
-      );
-    }
-    seen.add(id);
+function syncCustomIdTracker(edit, oldCustomId, deps) {
+  if (edit.column !== CUSTOM_ID_COLUMN) return;
+  const liveActivity = deps.adapter.getActivity(edit.activityId);
+  const rawValue = liveActivity ? liveActivity.customId : null;
+  const newCustomId = typeof rawValue === "string" ? rawValue : null;
+  if (oldCustomId !== newCustomId) {
+    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
   }
 }
-async function dispatchPersistenceAcknowledge(action, deps) {
-  const activities = action.activities ?? [];
-  const links = action.links ?? [];
-  const reconciledProgress = action.reconciledProgress ?? [];
-  assertValidReconciledProgress(reconciledProgress, deps);
-  const activityOwnerByBackendId = /* @__PURE__ */ new Map();
-  for (const activity of deps.adapter.getAllActivities()) {
-    if (activity.proplannerId != null) {
-      activityOwnerByBackendId.set(activity.proplannerId, String(activity.id));
-    }
-  }
-  const linkOwnerByBackendId = /* @__PURE__ */ new Map();
-  for (const link of deps.adapter.getAllLinks()) {
-    if (link.proplannerId != null) {
-      linkOwnerByBackendId.set(link.proplannerId, String(link.id));
-    }
+function recordConstraintPrior(priors, edit, beforeSnap) {
+  if (!isConstraintEditColumn(edit.column)) return;
+  const activityKey = String(edit.activityId);
+  if (priors.has(activityKey)) return;
+  const preBatchSnapshot = beforeSnap.get(activityKey);
+  if (!preBatchSnapshot) return;
+  priors.set(activityKey, preBatchSnapshot.constraintDate ?? null);
+}
+function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const candidateId of ids) {
+    if (!beforeSnap.has(candidateId)) missing.add(candidateId);
   }
-  assertValidAssignments(
-    activities,
-    "activity",
-    (id) => {
-      const activity = deps.adapter.getActivity(id);
-      return {
-        exists: activity !== null,
-        current: activity?.proplannerId ?? null
-      };
-    },
-    activityOwnerByBackendId
-  );
-  assertValidAssignments(
-    links,
-    "link",
-    (id) => {
-      const link = deps.adapter.getLink(id);
-      return { exists: link !== null, current: link?.proplannerId ?? null };
-    },
-    linkOwnerByBackendId
-  );
-  const activityChanges = [];
-  const linkChanges = [];
-  const progressToApply = reconciledProgress.filter((entry) => {
-    const current = deps.adapter.getActivity(String(entry.activityId));
-    return current !== null && current.progress !== entry.progress;
-  });
-  const touchedForProgress = new Set(
-    progressToApply.map((entry) => String(entry.activityId))
-  );
-  const parentsToRollup = /* @__PURE__ */ new Set();
-  for (const entry of progressToApply) {
-    const activity = deps.adapter.getActivity(String(entry.activityId));
-    if (activity && !isRootParent(activity.parentId)) {
-      parentsToRollup.add(String(activity.parentId));
-      touchedForProgress.add(String(activity.parentId));
+  if (missing.size === 0) return;
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
     }
   }
-  const beforeProgressSnap = await snapshotActivities(
-    deps.adapter,
-    touchedForProgress
-  );
-  deps.adapter.batchUpdate(() => {
-    for (const entry of progressToApply) {
-      deps.adapter.setActivityField(
-        String(entry.activityId),
-        "progress",
-        entry.progress
-      );
-    }
-    for (const parentId of parentsToRollup) {
-      recomputeRollupCascadesForParent(parentId, deps.adapter);
-    }
-    for (const id of touchedForProgress) {
-      const before = beforeProgressSnap.get(id);
-      const after = deps.adapter.getActivity(id);
-      if (!before || !after || before.progress === after.progress) continue;
-      activityChanges.push({
-        id,
-        kind: "updated",
-        fields: {
-          progress: { before: before.progress, after: after.progress }
-        },
-        after: { ...after }
-      });
-    }
-    for (const assignment of activities) {
-      const before = deps.adapter.getActivity(assignment.id);
-      if (!before || before.proplannerId === assignment.proplannerId) continue;
-      const previousProplannerId = before.proplannerId;
-      deps.adapter.setActivityField(
-        assignment.id,
-        "proplannerId",
-        assignment.proplannerId
-      );
-      activityChanges.push({
-        id: assignment.id,
-        kind: "updated",
-        fields: {
-          proplannerId: {
-            before: previousProplannerId,
-            after: assignment.proplannerId
-          }
-        },
-        after: { ...before, proplannerId: assignment.proplannerId }
-      });
-    }
-    for (const assignment of links) {
-      const before = deps.adapter.getLink(assignment.id);
-      if (!before || before.proplannerId === assignment.proplannerId) continue;
-      const previousProplannerId = before.proplannerId;
-      deps.adapter.setLinkProplannerId(assignment.id, assignment.proplannerId);
-      linkChanges.push({
-        id: assignment.id,
-        kind: "updated",
-        fields: {
-          proplannerId: {
-            before: previousProplannerId,
-            after: assignment.proplannerId
-          }
-        },
-        after: { ...before, proplannerId: assignment.proplannerId }
-      });
-    }
-  });
-  return {
-    ok: true,
-    changes: {
-      source: action,
-      activities: activityChanges,
-      links: linkChanges,
-      calendars: [],
-      trackingEvents: []
-    }
-  };
 }
 
 // src/baselines/normalize-baseline-point.ts
@@ -13805,55 +14408,6 @@ function recomputeAllPonderators(criterion, adapter) {
   });
 }
 
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
-  }
-}
-function parentsDeepestFirst(adapter) {
-  const parents = /* @__PURE__ */ new Set();
-  adapter.forEachActivity((_activity, id) => {
-    if (adapter.getChildren(id).length > 0) parents.add(id);
-  });
-  const depthById = /* @__PURE__ */ new Map();
-  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
-  return [...parents].sort(
-    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
-  );
-}
-function depthOf2(id, adapter) {
-  let depth = 0;
-  let current = id;
-  while (current && current !== "0") {
-    if (!adapter.getActivity(current)) break;
-    depth += 1;
-    current = adapter.getParentId(current);
-  }
-  return depth;
-}
-function rollupParent(parentId, adapter) {
-  const childIds = adapter.getChildren(parentId);
-  if (childIds.length === 0) return;
-  const children = [];
-  for (const childId of childIds) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    children.push({
-      progress: Number(child.progress ?? 0),
-      ponderator: Number(child.ponderator ?? 0)
-    });
-  }
-  const rollup = computeWeightedProgressRollup(children);
-  if (rollup !== null) {
-    adapter.setActivityField(
-      parentId,
-      COLUMN.PROGRESS,
-      roundProgressPerLevel(rollup)
-    );
-  }
-}
-
 // src/dispatch/shared/baseline-weighted-fields.ts
 function recomputeBaselineWeightedFields(deps, criterion) {
   recomputeAllPonderators(criterion, deps.adapter);
@@ -14243,11 +14797,8 @@ async function performDispatch(action, options, deps) {
   if (action.kind === "sir-sync") {
     return dispatchSirSync(action, deps);
   }
-  if (action.kind === "sir-approve") {
-    return dispatchSirApprove(action, options, deps);
-  }
   if (action.kind === "activity-lookahead-sync") {
-    return dispatchActivityLookaheadSync(action, deps);
+    return dispatchActivityLookaheadSync(action, options, deps);
   }
   if (action.kind === "inline-edit" && (action.column === COLUMN.CUSTOM_PREDECESSORS || action.column === COLUMN.CUSTOM_SUCESSORS)) {
     return dispatchInlineEditLinks(action, options, deps);
@@ -17325,79 +17876,8 @@ var HierarchyIndex = class {
   }
 };
 
-// src/internal/state/view-state.ts
-var ViewStateStore = class {
-  checkedSet = /* @__PURE__ */ new Set();
-  hiddenSet = /* @__PURE__ */ new Set();
-  activeFilter = null;
-  activeOrder = null;
-  isChecked(activityId) {
-    return this.checkedSet.has(activityId);
-  }
-  isVisible(activityId) {
-    return !this.hiddenSet.has(activityId);
-  }
-  hiddenIds() {
-    return [...this.hiddenSet];
-  }
-  getActiveFilter() {
-    return this.activeFilter;
-  }
-  setActiveFilter(nextFilter) {
-    this.activeFilter = nextFilter;
-  }
-  getActiveOrder() {
-    return this.activeOrder;
-  }
-  setActiveOrder(nextOrder) {
-    this.activeOrder = nextOrder;
-  }
-  checkedIds() {
-    return [...this.checkedSet];
-  }
-  checkedCount() {
-    return this.checkedSet.size;
-  }
-  setChecked(activityId, nextChecked) {
-    if (nextChecked === this.checkedSet.has(activityId)) return false;
-    if (nextChecked) this.checkedSet.add(activityId);
-    else this.checkedSet.delete(activityId);
-    return true;
-  }
-  setVisible(activityId, nextVisible) {
-    if (nextVisible === !this.hiddenSet.has(activityId)) return false;
-    if (nextVisible) this.hiddenSet.delete(activityId);
-    else this.hiddenSet.add(activityId);
-    return true;
-  }
-  forget(activityId) {
-    this.checkedSet.delete(activityId);
-    this.hiddenSet.delete(activityId);
-  }
-  hydrate(seed2) {
-    this.checkedSet = new Set(seed2.checkedIds ?? []);
-    this.hiddenSet = new Set(seed2.hiddenIds ?? []);
-    this.activeFilter = null;
-    this.activeOrder = null;
-  }
-  snapshot() {
-    return {
-      checked: new Set(this.checkedSet),
-      hidden: new Set(this.hiddenSet),
-      activeFilter: this.activeFilter,
-      activeOrder: this.activeOrder
-    };
-  }
-  restore(snapshot) {
-    this.checkedSet = new Set(snapshot.checked);
-    this.hiddenSet = new Set(snapshot.hidden);
-    this.activeFilter = snapshot.activeFilter;
-    this.activeOrder = snapshot.activeOrder;
-  }
-};
-
 // src/internal/state/schedule-state.ts
-var ScheduleState = class {
+var ScheduleState = class _ScheduleState {
   _activities = /* @__PURE__ */ new Map();
   _lastStartDate = /* @__PURE__ */ new Map();
   _promotionSnapshot = /* @__PURE__ */ new Map();
@@ -17419,22 +17899,52 @@ var ScheduleState = class {
   _promotionSnapshotBefore = null;
   _calendar;
   _flags;
+  _calendarSnapshot;
   constructor(snapshot, buildOrderComparator = () => null) {
     this._buildOrderComparator = buildOrderComparator;
+    this._calendarSnapshot = cloneDomainValue(snapshot.calendars);
     for (const activity of snapshot.activities) {
       this._activities.set(activity.id, activity);
     }
     for (const link of snapshot.links) {
-      this._links.set(String(link.id), link);
-      this._indexLink(link);
+      const normalized2 = {
+        ...link,
+        freeSlackHours: link.freeSlackHours ?? null,
+        isCritical: link.isCritical === true
+      };
+      this._links.set(String(link.id), normalized2);
+      this._indexLink(normalized2);
     }
     this._calendar = new CalendarCalculator(
-      createCalendarSetup(snapshot.calendars)
+      createCalendarSetup(this._calendarSnapshot)
     );
     this._flags = buildFlags(snapshot);
     this._hierarchy = new HierarchyIndex(this._activities);
     this._hierarchy.rebuild();
   }
+  fork() {
+    const fork = new _ScheduleState(
+      {
+        activities: this.getAllActivities().map(cloneCoreActivity),
+        links: this.getAllLinks().map((link) => ({ ...link })),
+        calendars: cloneDomainValue(this._calendarSnapshot)
+      },
+      this._buildOrderComparator
+    );
+    fork._viewState.restore(cloneDomainValue(this._viewState.snapshot()));
+    fork._lastStartDate = new Map(
+      Array.from(this._lastStartDate, ([id, date2]) => [id, new Date(date2)])
+    );
+    fork._promotionSnapshot = new Map(
+      Array.from(this._promotionSnapshot, ([id, snapshot]) => [
+        id,
+        cloneDomainValue(snapshot)
+      ])
+    );
+    fork._flags = cloneDomainValue(this._flags);
+    fork._filterProjection = cloneDomainValue(this._filterProjection);
+    return fork;
+  }
   getAllActivities() {
     return Array.from(this._activities.values());
   }
@@ -17544,6 +18054,18 @@ var ScheduleState = class {
     this._viewState.setActiveOrder(nextOrder);
     this.invalidateDerivedOrder();
   }
+  setRelativePlacementPin(activityId, pin) {
+    this._viewState.setRelativePlacementPin(String(activityId), pin);
+    this.invalidateVisualOrderIds();
+  }
+  getRelativePlacementPins() {
+    return this._viewState.getRelativePlacementPins();
+  }
+  restoreRelativePlacementPins(pins) {
+    this._viewState.restoreRelativePlacementPins(pins);
+    this._filterProjection = null;
+    this.invalidateVisualOrderIds();
+  }
   /**
    * Rebuild-on-demand, memoized: at most one build per invalidation, never one
    * per comparison. getChildrenInVisualOrder asks for this once and then sorts a
@@ -17692,9 +18214,14 @@ var ScheduleState = class {
   addLink(link) {
     this._writeCapture.noteLinkAdd(String(link.id));
     const superseded = this._links.get(String(link.id));
-    if (superseded) this._deindexLink(superseded);
-    this._links.set(String(link.id), { ...link });
-    this._indexLink(link);
+    if (superseded) this._deindexLink(superseded);
+    const normalized2 = {
+      ...link,
+      freeSlackHours: link.freeSlackHours ?? null,
+      isCritical: link.isCritical === true
+    };
+    this._links.set(String(link.id), normalized2);
+    this._indexLink(normalized2);
   }
   _indexLink(link) {
     pushLinkRef(this._outgoing, String(link.source), link.id);
@@ -17745,10 +18272,14 @@ var ScheduleState = class {
     const activity = this.getActivity(activityId);
     if (activity) this._writeCapture.noteRemove(String(activityId), activity);
     const key = String(activityId);
-    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key)) {
+    const relativePlacementPins = this._viewState.getRelativePlacementPins();
+    const hasDependentPin = [...relativePlacementPins.values()].some(
+      ({ referenceId }) => referenceId === key
+    );
+    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key) || relativePlacementPins.has(key) || hasDependentPin) {
       this._captureViewStateOnce();
-      this._viewState.forget(key);
     }
+    this._viewState.forget(key);
     this._activities.delete(activityId);
     if (this._lastStartDate.has(String(activityId))) {
       this._captureLastStartDateOnce();
@@ -17847,7 +18378,7 @@ var ScheduleState = class {
 };
 var EMPTY_LINK_IDS = [];
 function isMutableLinkField(field) {
-  return field === LINK_PROPERTY.LAG || field === LINK_PROPERTY.TYPE;
+  return field === LINK_PROPERTY.LAG || field === LINK_PROPERTY.TYPE || field === LINK_PROPERTY.FREE_SLACK_HOURS || field === LINK_PROPERTY.IS_CRITICAL;
 }
 function fieldAffectsVisualOrder(field) {
   return field === ACTIVITY_PROPERTY.PARENT || field === ACTIVITY_PROPERTY.CORRELATIVE_ID;
@@ -17968,12 +18499,7 @@ function buildPipelineContext(adapter, options) {
     activityReader: createStateBackedActivityReader(adapter),
     dateFormat: options.dateFormat ?? "YYYY-MM-DD",
     customHours: options.customHours ?? {},
-    hoursPerDay: options.hoursPerDay,
-    // ISSUE-057 (CP6): sin default. Un comando de duración sin inputUnit se
-    // rechaza en el pipeline; el resto de columnas no lo leen. La clave se
-    // OMITE cuando no se declaró (exactOptionalPropertyTypes), no se pone a
-    // undefined.
-    ...options.inputUnit !== void 0 ? { inputUnit: options.inputUnit } : {}
+    hoursPerDay: options.hoursPerDay
   };
 }
 
@@ -17983,15 +18509,26 @@ function willRunCriticalPath(action) {
 }
 
 // src/dispatch/undo/undo-entry.ts
-function buildHistoryChangeSet(changes) {
-  const activitiesWithoutAfter = changes.activities.map((entry) => ({
+var DERIVED_LINK_FIELDS = /* @__PURE__ */ new Set(["freeSlackHours", "isCritical"]);
+function withoutDerivedFields(entry, derivedFields) {
+  const fields = Object.fromEntries(
+    Object.entries(entry.fields ?? {}).filter(
+      ([field]) => !derivedFields.has(field)
+    )
+  );
+  if (entry.kind === "updated" && Object.keys(fields).length === 0) return null;
+  return {
     ...entry,
+    ...entry.fields === void 0 ? {} : { fields },
     after: null
-  }));
-  const linksWithoutAfter = changes.links.map((entry) => ({
+  };
+}
+function buildHistoryChangeSet(changes) {
+  const activitiesWithoutAfter = changes.activities.map((entry) => ({
     ...entry,
     after: null
   }));
+  const linksWithoutAfter = changes.links.map((entry) => withoutDerivedFields(entry, DERIVED_LINK_FIELDS)).filter((entry) => entry !== null);
   const source = changes.source.kind === "activity-batch" ? { ...changes.source, items: [], links: [] } : changes.source;
   return cloneDomainValue({
     ...changes,
@@ -18000,8 +18537,25 @@ function buildHistoryChangeSet(changes) {
     links: linksWithoutAfter
   });
 }
-function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
-  return { changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks };
+function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, relativePlacementPinsBefore, relativePlacementPinsAfter) {
+  return {
+    changeSet,
+    beforeSnap,
+    beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
+    afterSnap,
+    afterLinks: resetDerivedLinkSnapshots(afterLinks),
+    relativePlacementPinsBefore,
+    relativePlacementPinsAfter
+  };
+}
+function resetDerivedLinkSnapshots(snapshots) {
+  if (!snapshots) return void 0;
+  return new Map(
+    Array.from(snapshots, ([id, link]) => [
+      id,
+      { ...link, freeSlackHours: null, isCritical: false }
+    ])
+  );
 }
 function captureCreatedSnapshots(state, changeSet) {
   const afterSnap = /* @__PURE__ */ new Map();
@@ -18053,8 +18607,7 @@ function mergeCoalesced(top, next) {
   };
   return buildUndoEntry(changeSet);
 }
-function getDispatchHistoryPolicy(action, options) {
-  if (options?.preview === true) return "skip";
+function getDispatchHistoryPolicy(action) {
   if (action.kind === "persistence-acknowledge") return "clear-on-success";
   if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "activity-clipboard-clear" || action.kind === "activity-copy" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
     return "skip";
@@ -18295,12 +18848,14 @@ function applyChangeSetSide(state, entry, side) {
       );
     }
   }
+  const pins = side === "before" ? entry.relativePlacementPinsBefore : entry.relativePlacementPinsAfter;
+  if (pins !== void 0) state.restoreRelativePlacementPins(pins);
 }
 
 // src/dispatch/undo/undo-recorder.ts
 var DEFAULT_MAX_DEPTH = 100;
 var COALESCE_WINDOW_MS = 600;
-var UndoRecorder = class {
+var UndoRecorder = class _UndoRecorder {
   constructor(maxDepth = DEFAULT_MAX_DEPTH) {
     this.maxDepth = maxDepth;
   }
@@ -18309,6 +18864,14 @@ var UndoRecorder = class {
   redoStack = [];
   _lastKey = null;
   _lastTime = 0;
+  fork() {
+    const fork = new _UndoRecorder(this.maxDepth);
+    fork.undoStack.push(...cloneDomainValue(this.undoStack));
+    fork.redoStack.push(...cloneDomainValue(this.redoStack));
+    fork._lastKey = this._lastKey;
+    fork._lastTime = this._lastTime;
+    return fork;
+  }
   record(entry, coalesceKey = null, now = 0) {
     const top = this.undoStack[this.undoStack.length - 1];
     if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top, entry)) {
@@ -18432,40 +18995,56 @@ function buildStateSnapshot(activities, links, calendars, baseCalendars = []) {
 }
 
 // src/boundary/save/activity-changes.ts
-var PERSISTABLE_ACTIVITY_FIELDS = [
-  "id",
-  "proplannerId",
-  "parentId",
-  "name",
-  "description",
-  "type",
-  "startDate",
-  "endDate",
-  "durationHours",
-  "constraintType",
-  "constraintDate",
-  "autoScheduling",
-  "calendarId",
-  "assignedDefaultCalendar",
-  "dateOrigin",
-  "progress",
-  "cost",
-  "usedCost",
-  "realCost",
-  "workHours",
-  "realWorkHours",
-  "ponderator",
-  "hasCustomPonderator",
-  "correlativeId",
-  "uniqueCorrelativeId",
-  "customId",
-  "subcontractId",
-  "isLookahead",
-  "newActivityIds",
-  "hasNewActivities",
-  "responsableIds",
-  "tagIds"
-];
+var ACTIVITY_SAVE_FIELD_POLICY = {
+  id: "ignored",
+  proplannerId: "ignored",
+  parentId: "tracked",
+  name: "tracked",
+  description: "tracked",
+  type: "tracked",
+  startDate: "tracked",
+  endDate: "tracked",
+  durationHours: "tracked",
+  constraintType: "tracked",
+  constraintDate: "tracked",
+  autoScheduling: "tracked",
+  calendarId: "tracked",
+  assignedDefaultCalendar: "ignored",
+  dateOrigin: "tracked",
+  progress: "tracked",
+  cost: "tracked",
+  usedCost: "tracked",
+  realCost: "tracked",
+  workHours: "tracked",
+  realWorkHours: "tracked",
+  ponderator: "tracked",
+  hasCustomPonderator: "tracked",
+  correlativeId: "tracked",
+  uniqueCorrelativeId: "tracked",
+  customId: "tracked",
+  subcontractId: "tracked",
+  isLookahead: "tracked",
+  hasLookaheadTasks: "ignored",
+  newActivityIds: "tracked",
+  hasNewActivities: "tracked",
+  isNewActivity: "ignored",
+  pendingRequestIds: "ignored",
+  responsableIds: "tracked",
+  tagIds: "tracked",
+  baselinePoints: "ignored",
+  baselineSnapshot: "ignored",
+  recursiveDurationHours: "ignored",
+  isCritical: "ignored",
+  freeSlackHours: "ignored",
+  calendarDuration: "ignored",
+  expectedProgress: "ignored",
+  expectedProgressBaseline: "ignored",
+  status: "ignored",
+  criticalPath: "ignored"
+};
+var PERSISTABLE_ACTIVITY_FIELDS = Object.keys(ACTIVITY_SAVE_FIELD_POLICY).filter((field) => {
+  return ACTIVITY_SAVE_FIELD_POLICY[field] === "tracked";
+});
 var DATE_FIELDS2 = /* @__PURE__ */ new Set([
   "startDate",
   "endDate",
@@ -18493,7 +19072,6 @@ function snapshotFieldValue(field, value) {
   return value;
 }
 function activityChangedSince(current, saved) {
-  if (current.assignedDefaultCalendar) return true;
   for (const field of PERSISTABLE_ACTIVITY_FIELDS) {
     if (!fieldEquals(field, current[field], saved[field])) return true;
   }
@@ -18511,15 +19089,35 @@ function dateEquals(current, saved) {
   return currentTime === savedTime;
 }
 function idArrayEquals(current, saved) {
-  const currentIds = Array.isArray(current) ? [...current].map(String).sort() : [];
-  const savedIds = Array.isArray(saved) ? [...saved].map(String).sort() : [];
-  if (currentIds.length !== savedIds.length) return false;
-  return currentIds.every((value, index) => value === savedIds[index]);
+  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: "ignored",
+  source: "tracked",
+  target: "tracked",
+  type: "tracked",
+  lag: "tracked",
+  freeSlackHours: "ignored",
+  isCritical: "ignored",
+  ganttId: "ignored",
+  sectorId: "ignored",
+  proplannerId: "ignored"
+};
+var TRACKED_LINK_FIELDS = Object.keys(LINK_SAVE_FIELD_POLICY).filter((field) => {
+  return LINK_SAVE_FIELD_POLICY[field] === "tracked";
+});
 function linkChangedSince(baseline, current) {
-  return baseline.source !== current.source || baseline.target !== current.target || baseline.lag !== current.lag || baseline.type !== current.type;
+  return TRACKED_LINK_FIELDS.some(
+    (field) => baseline[field] !== current[field]
+  );
 }
 function checkNoUpdatedLinks(baseline, current) {
   const baselineById = new Map(
@@ -18533,23 +19131,73 @@ function checkNoUpdatedLinks(baseline, current) {
 }
 
 // src/boundary/save/save-tracker.ts
-var SaveTracker = class {
+function hasPersistedIdentity(proplannerId) {
+  const isNewIdentity = proplannerId == null || proplannerId === 0;
+  if (isNewIdentity) return false;
+  const isValidPersistedIdentity = typeof proplannerId === "number" && Number.isSafeInteger(proplannerId) && proplannerId > 0;
+  if (!isValidPersistedIdentity) {
+    throw new Error(`invalid proplannerId ${String(proplannerId)}`);
+  }
+  return true;
+}
+function assertValidPersistedIdentities(activities, links) {
+  for (const activity of activities) {
+    hasPersistedIdentity(activity.proplannerId);
+  }
+  for (const link of links) {
+    hasPersistedIdentity(link.proplannerId);
+  }
+}
+var SaveTracker = class _SaveTracker {
+  trackingEnabled;
   initialized = false;
   dirtyActivityIds = /* @__PURE__ */ new Set();
   dirtyLinkIds = /* @__PURE__ */ new Set();
+  initialCalendarRepairIds = /* @__PURE__ */ new Set();
   linksAtLastSave = /* @__PURE__ */ new Map();
   activitiesAtLastSave = /* @__PURE__ */ new Map();
+  constructor(trackingEnabled = true) {
+    this.trackingEnabled = trackingEnabled;
+  }
+  fork() {
+    const fork = new _SaveTracker(false);
+    fork.initialized = this.initialized;
+    for (const [linkId, link] of this.linksAtLastSave) {
+      fork.linksAtLastSave.set(linkId, cloneDomainValue(link));
+    }
+    for (const [activityId, activity] of this.activitiesAtLastSave) {
+      fork.activitiesAtLastSave.set(activityId, cloneDomainValue(activity));
+    }
+    return fork;
+  }
   init(activities, links) {
+    if (!this.trackingEnabled) return;
+    assertValidPersistedIdentities(activities, links);
     this.snapshotActivities(activities);
     this.snapshotLinks(links);
+    for (const activity of activities) {
+      if (activity.assignedDefaultCalendar) {
+        const activityId = String(activity.id);
+        this.initialCalendarRepairIds.add(activityId);
+        this.dirtyActivityIds.add(activityId);
+      }
+    }
     this.initialized = true;
   }
+  acknowledge(activities, links) {
+    if (!this.trackingEnabled) return;
+    assertValidPersistedIdentities(activities, links);
+    this.snapshotActivities(activities);
+    this.snapshotLinks(links);
+  }
   snapshotActivities(activities) {
+    if (!this.trackingEnabled) return;
     this.activitiesAtLastSave.clear();
     this.dirtyActivityIds.clear();
+    this.initialCalendarRepairIds.clear();
     for (const activity of activities) {
       const activityId = String(activity.id);
-      if (activity.proplannerId == null) {
+      if (!hasPersistedIdentity(activity.proplannerId)) {
         this.dirtyActivityIds.add(activityId);
         continue;
       }
@@ -18569,11 +19217,12 @@ var SaveTracker = class {
     }
   }
   snapshotLinks(links) {
+    if (!this.trackingEnabled) return;
     this.linksAtLastSave.clear();
     this.dirtyLinkIds.clear();
     for (const link of links) {
       const linkId = String(link.id);
-      if (link.proplannerId == null) {
+      if (!hasPersistedIdentity(link.proplannerId)) {
         this.dirtyLinkIds.add(linkId);
         continue;
       }
@@ -18588,12 +19237,11 @@ var SaveTracker = class {
     }
   }
   recordChanges(activities, links, getActivity, getLink) {
-    if (!this.initialized) return;
+    if (!this.trackingEnabled || !this.initialized) return;
     for (const change of activities) {
       const activityId = String(change.id);
       const current = getActivity(activityId);
-      const saved = this.activitiesAtLastSave.get(activityId);
-      if (current === null ? saved !== void 0 : current.proplannerId == null || saved === void 0 || activityChangedSince(current, saved.persistable)) {
+      if (this.activityIsDirty(activityId, current)) {
         this.dirtyActivityIds.add(activityId);
       } else {
         this.dirtyActivityIds.delete(activityId);
@@ -18602,81 +19250,147 @@ var SaveTracker = class {
     for (const change of links) {
       const linkId = String(change.id);
       const current = getLink(linkId);
-      const saved = this.linksAtLastSave.get(linkId);
-      if (current === null ? saved !== void 0 : current.proplannerId == null || saved === void 0 || linkChangedSince(saved, current)) {
+      if (this.linkIsDirty(linkId, current)) {
         this.dirtyLinkIds.add(linkId);
       } else {
         this.dirtyLinkIds.delete(linkId);
       }
     }
   }
-  acknowledgePersistedLookahead(activityIds, getActivity) {
-    if (!this.initialized) return;
-    for (const activityId of activityIds) {
+  activityIsDirty(activityId, current) {
+    const saved = this.activitiesAtLastSave.get(activityId);
+    if (current === null) return saved !== void 0;
+    return this.initialCalendarRepairIds.has(activityId) || !hasPersistedIdentity(current.proplannerId) || saved === void 0 || activityChangedSince(current, saved.persistable);
+  }
+  linkIsDirty(linkId, current) {
+    const saved = this.linksAtLastSave.get(linkId);
+    if (current === null) return saved !== void 0;
+    return !hasPersistedIdentity(current.proplannerId) || saved === void 0 || linkChangedSince(saved, current);
+  }
+  acknowledgePersistedLookahead(changes, getActivity) {
+    if (!this.trackingEnabled || !this.initialized) return;
+    const acknowledgements = changes.map((change) => {
+      const activityId = typeof change === "string" ? change : String(change.id);
       const current = getActivity(activityId);
       const saved = this.activitiesAtLastSave.get(activityId);
-      if (current === null || saved === void 0) continue;
+      const isUnknownPersistedActivity = current === null || saved === void 0;
+      if (isUnknownPersistedActivity) {
+        throw new Error(`unknown persisted activity "${activityId}"`);
+      }
+      return {
+        activityId,
+        acknowledgesLookahead: typeof change === "string" || Boolean(change.fields?.isLookahead),
+        acknowledgesProgress: typeof change !== "string" && Boolean(change.fields?.progress),
+        current,
+        saved
+      };
+    });
+    for (const {
+      activityId,
+      acknowledgesLookahead,
+      acknowledgesProgress,
+      current,
+      saved
+    } of acknowledgements) {
       const persistable = {
         ...saved.persistable,
-        isLookahead: current.isLookahead
+        ...acknowledgesLookahead ? { isLookahead: current.isLookahead } : {},
+        ...acknowledgesProgress ? { progress: current.progress } : {}
       };
       this.activitiesAtLastSave.set(activityId, {
         ...saved,
         persistable
       });
-      if (current.proplannerId == null || activityChangedSince(current, persistable)) {
+      if (this.initialCalendarRepairIds.has(activityId) || !hasPersistedIdentity(current.proplannerId) || activityChangedSince(current, persistable)) {
         this.dirtyActivityIds.add(activityId);
       } else {
         this.dirtyActivityIds.delete(activityId);
       }
     }
   }
+  hasCheckpointActivityId(activityId) {
+    return this.activitiesAtLastSave.has(activityId);
+  }
+  hasCheckpointLinkId(linkId) {
+    return this.linksAtLastSave.has(linkId);
+  }
   hasUnsavedChanges() {
-    return this.initialized && (this.dirtyActivityIds.size > 0 || this.dirtyLinkIds.size > 0);
+    return this.trackingEnabled && this.initialized && (this.dirtyActivityIds.size > 0 || this.dirtyLinkIds.size > 0);
+  }
+  newActivities(getActivity) {
+    if (!this.trackingEnabled || !this.initialized) return [];
+    const activities = [];
+    for (const activityId of this.dirtyActivityIds) {
+      const activity = getActivity(activityId);
+      const isNewActivity = activity !== null && !hasPersistedIdentity(activity.proplannerId);
+      if (isNewActivity) activities.push(activity);
+    }
+    return activities;
+  }
+  newLinks(getLink) {
+    if (!this.trackingEnabled || !this.initialized) return [];
+    const links = [];
+    for (const linkId of this.dirtyLinkIds) {
+      const link = getLink(linkId);
+      const isNewLink = link !== null && !hasPersistedIdentity(link.proplannerId);
+      if (isNewLink) links.push(link);
+    }
+    return links;
+  }
+  deletedActivities(getActivity) {
+    if (!this.trackingEnabled || !this.initialized) return [];
+    const deleted = [];
+    for (const activityId of this.dirtyActivityIds) {
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (saved && getActivity(activityId) === null) {
+        deleted.push({ ...saved.deletedSnapshot });
+      }
+    }
+    return deleted;
   }
-  deletedActivities(activities) {
-    if (!this.initialized) return [];
-    const currentIds = new Set(
-      activities.map((activity) => String(activity.id))
-    );
+  deletedLinks(getLink) {
+    if (!this.trackingEnabled || !this.initialized) return [];
     const deleted = [];
-    for (const [activityId, saved] of this.activitiesAtLastSave) {
-      if (currentIds.has(activityId)) continue;
-      deleted.push({ ...saved.deletedSnapshot });
+    for (const linkId of this.dirtyLinkIds) {
+      const saved = this.linksAtLastSave.get(linkId);
+      if (saved && getLink(linkId) === null) deleted.push({ ...saved });
     }
     return deleted;
   }
-  deletedLinks(links) {
-    if (!this.initialized) return [];
-    const currentIds = new Set(links.map((link) => String(link.id)));
-    return Array.from(
-      this.linksAtLastSave.entries(),
-      ([linkId, saved]) => currentIds.has(linkId) ? null : { ...saved }
-    ).filter((link) => link !== null);
-  }
-  modifiedActivities(activities) {
-    if (!this.initialized) return [];
-    return activities.filter((activity) => {
-      if (activity.proplannerId == null) return false;
-      if (activity.assignedDefaultCalendar) return true;
-      const saved = this.activitiesAtLastSave.get(String(activity.id));
-      if (!saved) return true;
-      return activityChangedSince(activity, saved.persistable);
-    });
+  modifiedActivities(getActivity) {
+    if (!this.trackingEnabled || !this.initialized) return [];
+    const modified = [];
+    for (const activityId of this.dirtyActivityIds) {
+      const activity = getActivity(activityId);
+      if (activity === null || !hasPersistedIdentity(activity.proplannerId)) {
+        continue;
+      }
+      const saved = this.activitiesAtLastSave.get(activityId);
+      if (saved === void 0 || this.initialCalendarRepairIds.has(activityId) || activityChangedSince(activity, saved.persistable)) {
+        modified.push(activity);
+      }
+    }
+    return modified;
   }
-  modifiedLinks(links) {
-    if (!this.initialized) return [];
-    return links.filter((link) => {
-      if (link.proplannerId == null) return false;
-      const saved = this.linksAtLastSave.get(String(link.id));
-      if (!saved) return true;
-      return linkChangedSince(saved, link);
-    });
+  modifiedLinks(getLink) {
+    if (!this.trackingEnabled || !this.initialized) return [];
+    const modified = [];
+    for (const linkId of this.dirtyLinkIds) {
+      const link = getLink(linkId);
+      if (link === null) continue;
+      if (!hasPersistedIdentity(link.proplannerId)) continue;
+      const saved = this.linksAtLastSave.get(linkId);
+      if (saved === void 0 || linkChangedSince(saved, link)) {
+        modified.push(link);
+      }
+    }
+    return modified;
   }
   clear() {
     this.initialized = false;
     this.dirtyActivityIds.clear();
     this.dirtyLinkIds.clear();
+    this.initialCalendarRepairIds.clear();
     this.linksAtLastSave.clear();
     this.activitiesAtLastSave.clear();
   }
@@ -18730,14 +19444,14 @@ function isAutoSchedulable(progress) {
 }
 function parseConstraintLabel(label, reporter) {
   if (!label) return null;
-  const normalized = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
-  if (normalized === void 0) {
+  const normalized2 = CONSTRAINT_LABEL_MAP[label.toUpperCase()];
+  if (normalized2 === void 0) {
     reporter.warn(
       `[parseFromBackend] unknown constraint label "${label}" \u2014 defaulting to "asap"`
     );
     return DEFAULT_CONSTRAINT_TYPE;
   }
-  return normalized;
+  return normalized2;
 }
 function resolveConstraint(raw, reporter) {
   const constraintType = parseConstraintLabel(raw.constraint, reporter);
@@ -18778,6 +19492,24 @@ function parseIdList(raw) {
 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 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) {
   if (!Array.isArray(raw)) return [];
   return raw.map((point) => normalizeBaselinePoint(point, reporter)).filter((point) => point !== null);
@@ -18798,9 +19530,10 @@ function parseActivity(raw, context) {
   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: typeof raw.id === "number" ? raw.id : null,
+    proplannerId: normalizePersistedActivityId(raw.id),
     parentId: parseParentId(raw.parent_id),
     name: raw.name,
     description: raw.description ?? "",
@@ -18845,7 +19578,7 @@ function parseActivity(raw, context) {
       startDate,
       endDate
     }),
-    isCritical: Boolean(raw.is_critical),
+    isCritical,
     freeSlackHours: null,
     expectedProgress: null,
     expectedProgressBaseline: null,
@@ -19102,6 +19835,14 @@ function resolveLinkType(rawType) {
   if (isLinkTypeCode(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) {
@@ -19140,16 +19881,18 @@ function parseLink(link, activityIds, hoursPerDay) {
   }
   const ganttIdRaw = link.ganttId;
   const sectorIdRaw = link.sectorId;
-  const proplannerIdRaw = link.id;
+  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 } : {},
-    ...typeof proplannerIdRaw === "number" ? { proplannerId: proplannerIdRaw } : {}
+    ...proplannerId === void 0 ? {} : { proplannerId }
   };
 }
 function dedupeLinksBySignature(links) {
@@ -19276,6 +20019,9 @@ function createActivityIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createActivityIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -19307,6 +20053,9 @@ function createLinkIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createLinkIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -19342,6 +20091,9 @@ function createUniqueCorrelativeIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createUniqueCorrelativeIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -19469,7 +20221,7 @@ function selectGenerationStrategy(customId, useActivityCustomIdAsReference) {
 function cloneStats(stats) {
   return { ...stats, usedSuffixes: new Set(stats.usedSuffixes) };
 }
-var CustomIdTracker = class {
+var CustomIdTracker = class _CustomIdTracker {
   prefixMap = /* @__PURE__ */ new Map();
   processedIds = /* @__PURE__ */ new Set();
   _journalPrefixBefore = null;
@@ -19530,6 +20282,19 @@ var CustomIdTracker = class {
     this.defaultPrefix = options.defaultPrefix ?? DEFAULT_PREFIX;
     this.suffixIncrement = options.suffixIncrement ?? DEFAULT_SUFFIX_INCREMENT;
   }
+  fork() {
+    const fork = new _CustomIdTracker({
+      defaultPrefix: this.defaultPrefix,
+      suffixIncrement: this.suffixIncrement
+    });
+    for (const [prefix, stats] of this.prefixMap) {
+      fork.prefixMap.set(prefix, cloneStats(stats));
+    }
+    for (const customId of this.processedIds) {
+      fork.processedIds.add(customId);
+    }
+    return fork;
+  }
   extractPrefix(customId) {
     return extractPrefix(customId);
   }
@@ -20136,6 +20901,133 @@ function initializeCore(input) {
   };
 }
 
+// src/previsualization/canonical-digest.ts
+function normalized(value) {
+  if (value === void 0) return ["undefined"];
+  if (value === null) return ["null"];
+  if (typeof value === "string") return ["string", value];
+  if (typeof value === "boolean") return ["boolean", value];
+  if (typeof value === "number") {
+    return ["number", Object.is(value, -0) ? "-0" : String(value)];
+  }
+  if (typeof value === "bigint") return ["bigint", String(value)];
+  if (value instanceof Date) return ["date", String(value.getTime())];
+  if (Array.isArray(value)) return ["array", value.map(normalized)];
+  if (value instanceof Map) {
+    return [
+      "map",
+      Array.from(value, ([key, entry]) => [
+        normalized(key),
+        normalized(entry)
+      ]).sort(
+        (left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))
+      )
+    ];
+  }
+  if (value instanceof Set) {
+    return [
+      "set",
+      Array.from(value, normalized).sort(
+        (left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))
+      )
+    ];
+  }
+  if (typeof value === "object") {
+    return [
+      "object",
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalized(entry)])
+    ];
+  }
+  throw new TypeError(`Unsupported canonical value: ${typeof value}`);
+}
+function serializeCanonicalSchedule(value) {
+  return JSON.stringify(normalized(value));
+}
+
+// src/previsualization/reconciliation.ts
+function entityChanges(target, source) {
+  const targetById = new Map(
+    target.map((entity) => [String(entity.id), entity])
+  );
+  const sourceById = new Map(
+    source.map((entity) => [String(entity.id), entity])
+  );
+  const ids = [.../* @__PURE__ */ new Set([...targetById.keys(), ...sourceById.keys()])].sort();
+  const changes = [];
+  for (const id of ids) {
+    const before = sourceById.get(id);
+    const after = targetById.get(id);
+    if (after === void 0) {
+      changes.push({ id, kind: "deleted", after: null });
+      continue;
+    }
+    if (before === void 0) {
+      changes.push({ id, kind: "created", after: cloneDomainValue(after) });
+      continue;
+    }
+    const fields = changedFields(before, after);
+    if (Object.keys(fields).length > 0) {
+      changes.push({
+        id,
+        kind: "updated",
+        fields,
+        after: cloneDomainValue(after)
+      });
+    }
+  }
+  return changes;
+}
+function changedFields(before, after) {
+  const fields = {};
+  const keys = [
+    .../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])
+  ].sort();
+  for (const key of keys) {
+    if (serializeCanonicalSchedule(before[key]) !== serializeCanonicalSchedule(after[key])) {
+      fields[key] = {
+        before: cloneDomainValue(before[key]),
+        after: cloneDomainValue(after[key])
+      };
+    }
+  }
+  return fields;
+}
+function viewStateChanges(target, source) {
+  const selectedBefore = new Set(source.selectedIds.map(String));
+  const selectedAfter = new Set(target.selectedIds.map(String));
+  const hiddenBefore = new Set(source.hiddenIds.map(String));
+  const hiddenAfter = new Set(target.hiddenIds.map(String));
+  const targetIds = target.activities.map(({ id }) => String(id)).sort();
+  const changes = [];
+  for (const activityId of targetIds) {
+    const checkedBefore = selectedBefore.has(activityId);
+    const checkedAfter = selectedAfter.has(activityId);
+    const visibleBefore = !hiddenBefore.has(activityId);
+    const visibleAfter = !hiddenAfter.has(activityId);
+    if (checkedBefore === checkedAfter && visibleBefore === visibleAfter)
+      continue;
+    changes.push({
+      activityId,
+      ...checkedBefore === checkedAfter ? {} : { checked: { before: checkedBefore, after: checkedAfter } },
+      ...visibleBefore === visibleAfter ? {} : { visible: { before: visibleBefore, after: visibleAfter } }
+    });
+  }
+  return changes;
+}
+function createProjectionChangeSet(target, source) {
+  const orderChanged = serializeCanonicalSchedule(target.order) !== serializeCanonicalSchedule(source.order);
+  return {
+    source: { kind: "init" },
+    activities: entityChanges(target.activities, source.activities),
+    links: entityChanges(target.links, source.links),
+    calendars: entityChanges(target.calendars, source.calendars),
+    trackingEvents: [],
+    effects: [],
+    viewState: viewStateChanges(target, source),
+    ...orderChanged ? { order: cloneDomainValue(target.order) } : {}
+  };
+}
+
 // src/propagations/upward/date-gesture-preview.ts
 var emptyFormula = () => ({
   constantStart: null,
@@ -20281,7 +21173,10 @@ function evaluateEnd(formula, proposedEdgeTimeMs) {
 }
 
 // src/init/schedule-core.ts
-var PREVIEW_DISPATCH_KINDS = /* @__PURE__ */ new Set(["inline-edit", "bulk-edit", "dates-batch"]);
+var FORK_SOURCE = /* @__PURE__ */ Symbol("ScheduleCore.fork.source");
+function acknowledgesPersistence(action) {
+  return action.kind === "persistence-acknowledge" || action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true;
+}
 function changesRequireFilterProjectionRebuild(changes) {
   for (const change of changes.activities) {
     if (change.kind === "deleted") return true;
@@ -20299,16 +21194,46 @@ function collectChangedActivities(changes, adapter) {
   }
   return activities;
 }
+function changesAffectRelativePinProjection(changes, changedActivities, adapter, pins) {
+  if (pins.size === 0) return false;
+  if (changes.activities.some(
+    (change) => change.kind === "created" && pins.has(String(change.id))
+  )) {
+    return true;
+  }
+  const referenceIds = new Set(
+    [...pins.values()].map(({ referenceId }) => String(referenceId))
+  );
+  for (const activity of changedActivities) {
+    let activityId = String(activity.id);
+    while (activityId !== null) {
+      if (referenceIds.has(activityId)) return true;
+      activityId = adapter.getParentId(activityId);
+    }
+  }
+  return false;
+}
 function isCurrentFilterProjection(projection, filter, context) {
   if (projection === null || projection.filter !== filter) return false;
   const hasCurrentHours = projection.context.hoursPerDay === context.hoursPerDay;
   const hasCurrentLocale = projection.context.locale === context.locale;
   return hasCurrentHours && hasCurrentLocale;
 }
-var ScheduleCore = class {
+function relativePlacementPinsEqual(left, right) {
+  if (left.size !== right.size) return false;
+  for (const [activityId, pin] of left) {
+    const other = right.get(activityId);
+    if (other === void 0 || other.referenceId !== pin.referenceId || other.branchParentId !== pin.branchParentId || other.side !== pin.side) {
+      return false;
+    }
+  }
+  return true;
+}
+var ScheduleCore = class _ScheduleCore {
   _activityClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
+  _isFork;
   _undo = new UndoRecorder();
   _opQueue = Promise.resolve();
   _scheduleRevision = 0;
@@ -20339,6 +21264,42 @@ var ScheduleCore = class {
   _criticalPathRevision = -1;
   _activeCriticalPath = null;
   constructor(input) {
+    if (FORK_SOURCE in input) {
+      this._isFork = true;
+      const source = input[FORK_SOURCE];
+      const state = source.coreRuntime.state.fork();
+      this.coreRuntime = {
+        state,
+        scheduler: new AutoScheduler(state, source.coreRuntime.reporter),
+        sector: cloneDomainValue(source.coreRuntime.sector),
+        activityIdGenerator: source.coreRuntime.activityIdGenerator.fork(),
+        linkIdGenerator: source.coreRuntime.linkIdGenerator.fork(),
+        uniqueCorrelativeIdGenerator: source.coreRuntime.uniqueCorrelativeIdGenerator.fork(),
+        customIdTracker: source.coreRuntime.customIdTracker.fork(),
+        calendars: new Map(
+          Array.from(source.coreRuntime.calendars, ([id, calendar]) => [
+            id,
+            cloneDomainValue(calendar)
+          ])
+        ),
+        baseCalendars: cloneDomainValue(source.coreRuntime.baseCalendars),
+        clock: source.coreRuntime.clock,
+        reporter: source.coreRuntime.reporter
+      };
+      this._activityClipboard.value = cloneDomainValue(
+        source._activityClipboard.value
+      );
+      this._undo = source._undo.fork();
+      this._saveTracker = source._saveTracker.fork();
+      this._scheduleRevision = source._scheduleRevision;
+      this._pendingScheduleRevision = source._scheduleRevision;
+      this._criticalPathRevision = source._criticalPathRevision;
+      this._initPromise = Promise.resolve();
+      this._criticalPathReady = Promise.resolve(null);
+      this._ready = this._initPromise;
+      return;
+    }
+    this._isFork = false;
     const initialized = initializeCore(input);
     this.coreRuntime = {
       state: initialized.state,
@@ -20375,6 +21336,15 @@ var ScheduleCore = class {
   get ready() {
     return this._ready;
   }
+  fork() {
+    return this._enqueue(async () => {
+      await this._ready;
+      this.assertReady();
+      return new _ScheduleCore({
+        [FORK_SOURCE]: this
+      });
+    });
+  }
   get criticalPathReady() {
     return this._criticalPathReady;
   }
@@ -20427,6 +21397,21 @@ var ScheduleCore = class {
     this.assertReady();
     return readLink(this.coreRuntime.state, id);
   }
+  getLinksForActivityView(activityId) {
+    this.assertReady();
+    const state = this.coreRuntime.state;
+    const links = [];
+    const seen = /* @__PURE__ */ new Set();
+    const append = (linkId) => {
+      if (seen.has(linkId)) return;
+      seen.add(linkId);
+      const link = readLink(state, linkId);
+      if (link) links.push(link);
+    };
+    for (const linkId of state.getOutgoingLinkIds(activityId)) append(linkId);
+    for (const linkId of state.getIncomingLinkIds(activityId)) append(linkId);
+    return links;
+  }
   getAllLinksView() {
     this.assertReady();
     return readAllLinks(this.coreRuntime.state);
@@ -20524,91 +21509,65 @@ var ScheduleCore = class {
   }
   getModifiedLinks() {
     this.assertReady();
-    return this._saveTracker.modifiedLinks(this.getAllLinksView());
+    return this._saveTracker.modifiedLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
+  }
+  getNewLinks() {
+    this.assertReady();
+    return this._saveTracker.newLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
   }
   getModifiedActivities() {
     this.assertReady();
-    return this._saveTracker.modifiedActivities(this.coreRuntime.state.getAllActivities()).map(cloneDomainValue);
+    return this._saveTracker.modifiedActivities(
+      (activityId) => this.coreRuntime.state.getActivity(activityId)
+    ).map(cloneDomainValue);
+  }
+  getNewActivities() {
+    this.assertReady();
+    return this._saveTracker.newActivities(
+      (activityId) => this.coreRuntime.state.getActivity(activityId)
+    ).map(cloneDomainValue);
   }
   hasUnsavedChanges() {
     this.assertReady();
     return this._saveTracker.hasUnsavedChanges();
   }
-  /**
-   * Read-only view of the internal schedule revision. It moves once per
-   * substantive CANONICAL mutation (dispatch, undo, redo). It does NOT move
-   * for a preview dispatch nor for `applyPreviewInverse`: comparing the value
-   * captured in `PreviewDispatchInfo.revision` against the current one
-   * answers "did the schedule change while the preview was open".
-   */
+  /** Read-only revision; moves once per substantive mutation. */
   getScheduleRevision() {
     return this._scheduleRevision;
   }
-  /**
-   * Exit channel for a preview dispatch (`DispatchOptions.preview`): applies
-   * the inverse ChangeSet the preview returned, restoring the canonical
-   * state exactly. Like the preview itself it leaves no session trace: no
-   * save-tracker dirty, no undo entry, no effects, and the schedule revision
-   * does not move (see `getScheduleRevision`).
-   *
-   * Returns the ChangeSet to project to the view layer: the same changes as
-   * `inverse`, but with `after` images re-read from the restored state (the
-   * ones inside `inverse` were captured while the preview edit was applied).
-   */
-  applyPreviewInverse(inverse) {
-    return this._enqueue(async () => {
-      this.assertReady();
-      const state = this.coreRuntime.state;
-      const afterSnap = /* @__PURE__ */ new Map();
-      for (const change of inverse.activities) {
-        if (change.kind !== "deleted" && change.after) {
-          afterSnap.set(
-            String(change.id),
-            structuredCloneActivity(change.after)
-          );
-        }
-      }
-      const afterLinks = /* @__PURE__ */ new Map();
-      for (const change of inverse.links) {
-        if (change.kind !== "deleted" && change.after) {
-          afterLinks.set(String(change.id), { ...change.after });
-        }
-      }
-      const entry = buildUndoEntry(
-        inverse,
-        void 0,
-        void 0,
-        afterSnap,
-        afterLinks
-      );
-      applyRedo(state, entry);
-      if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
-      const restored = {
-        ...inverse,
-        activities: inverse.activities.map((change) => {
-          if (change.kind === "deleted") return { ...change, after: null };
-          const live = state.getActivity(String(change.id));
-          return {
-            ...change,
-            after: live ? structuredCloneActivity(live) : null
-          };
-        }),
-        links: inverse.links.map((change) => {
-          if (change.kind === "deleted") return { ...change, after: null };
-          const live = state.getLink(String(change.id));
-          return { ...change, after: live ? snapshotToLink(live) : null };
-        })
-      };
-      return this._reapplyViewState(restored) ?? restored;
+  getCanonicalDigest() {
+    this.assertReady();
+    const byId = (left, right) => String(left.id).localeCompare(String(right.id));
+    return serializeCanonicalSchedule({
+      sector: this.getSector(),
+      activities: [...this.getAllActivitiesView()].sort(byId),
+      links: [...this.getAllLinksView()].sort(byId),
+      calendars: [...this.getAllCalendars()].sort(byId),
+      baseCalendars: [...this.getBaseCalendars()].sort(byId)
+    });
+  }
+  createProjectionChangeSetFrom(source) {
+    this.assertReady();
+    source.assertReady();
+    const projectionOf = (core) => ({
+      activities: core.getAllActivitiesView(),
+      links: core.getAllLinksView(),
+      calendars: core.getAllCalendars(),
+      selectedIds: core.getSelectedActivityIds(),
+      hiddenIds: core.getHiddenActivityIds(),
+      order: collectBranchOrder(core.coreRuntime.state)
     });
+    return createProjectionChangeSet(projectionOf(this), projectionOf(source));
   }
   getDeletedActivitiesSinceLastSave() {
     this.assertReady();
-    return this._saveTracker.deletedActivities(this.coreRuntime.state.getAllActivities()).map(cloneDomainValue);
+    return this._saveTracker.deletedActivities(
+      (activityId) => this.coreRuntime.state.getActivity(activityId)
+    ).map(cloneDomainValue);
   }
   getDeletedLinksSinceLastSave() {
     this.assertReady();
-    return this._saveTracker.deletedLinks(this.getAllLinksView()).map(cloneDomainValue);
+    return this._saveTracker.deletedLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
   }
   _enqueue(work) {
     const workPromise = this._opQueue.then(work, work);
@@ -20684,11 +21643,11 @@ var ScheduleCore = class {
     });
   }
   async dispatch(action, options = {}) {
-    const admitted = options.preview === true ? false : this._beginScheduleMutation(action);
+    const admitted = this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
   async applyActivityBatch(action, options = {}) {
-    const admitted = options.preview === true ? false : this._beginScheduleMutation(action);
+    const admitted = this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
   async _dispatchInner(action, options = {}, admitted = false) {
@@ -20703,23 +21662,22 @@ var ScheduleCore = class {
   }
   async _runDispatch(action, options) {
     this.assertReady();
-    if (options.preview === true && !PREVIEW_DISPATCH_KINDS.has(action.kind)) {
+    if (this._isFork && acknowledgesPersistence(action)) {
       return {
         result: {
           ok: false,
-          reason: REJECTION_REASON.PREVIEW_UNSUPPORTED_ACTION
+          reason: REJECTION_REASON.SANDBOX_PERSISTENCE_FORBIDDEN
         },
         changedState: false
       };
     }
     const pipelineContext = buildPipelineContext(this.coreRuntime.state, {
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
-      dateFormat: this.coreRuntime.sector.dateFormat,
-      // ISSUE-057 (CP6): sin default silencioso 'days'; la clave se omite si
-      // no se declaró (exactOptionalPropertyTypes).
-      ...options.inputUnit !== void 0 ? { inputUnit: options.inputUnit } : {}
+      dateFormat: this.coreRuntime.sector.dateFormat
     });
-    const historyPolicy = getDispatchHistoryPolicy(action, options);
+    const historyPolicy = getDispatchHistoryPolicy(action);
+    const capturesRelativePlacementPins = action.kind === "activity-create" || action.kind === "activity-delete" || action.kind === "activity-batch" && action.mode === "replace";
+    const relativePlacementPinsBefore = capturesRelativePlacementPins ? new Map(this.coreRuntime.state.getRelativePlacementPins()) : void 0;
     const generatorSnapshot = [
       this.coreRuntime.activityIdGenerator.snapshot(),
       this.coreRuntime.linkIdGenerator.snapshot(),
@@ -20737,6 +21695,8 @@ var ScheduleCore = class {
         calendars: this.coreRuntime.calendars,
         activityIdGen: this.coreRuntime.activityIdGenerator,
         linkIdGen: this.coreRuntime.linkIdGenerator,
+        isActivityIdReserved: (activityId) => this._saveTracker.hasCheckpointActivityId(activityId),
+        isLinkIdReserved: (linkId) => this._saveTracker.hasCheckpointLinkId(linkId),
         uidGen: this.coreRuntime.uniqueCorrelativeIdGenerator,
         customIdTracker: this.coreRuntime.customIdTracker,
         reporter: this.coreRuntime.reporter,
@@ -20754,18 +21714,26 @@ var ScheduleCore = class {
       this.coreRuntime.state.endWriteCapture();
       this.coreRuntime.customIdTracker.commitCustomIdTransaction();
     }
+    if (result.ok) this._recordRelativePlacementPin(action, result.changes);
     if (result.ok && historyPolicy === "record" && changeSetIsSubstantive(result.changes)) {
       const created = captureCreatedSnapshots(
         this.coreRuntime.state,
         result.changes
       );
+      const relativePlacementPinsAfter = capturesRelativePlacementPins ? new Map(this.coreRuntime.state.getRelativePlacementPins()) : void 0;
+      const relativePlacementPinsChanged = relativePlacementPinsBefore !== void 0 && relativePlacementPinsAfter !== void 0 && !relativePlacementPinsEqual(
+        relativePlacementPinsBefore,
+        relativePlacementPinsAfter
+      );
       this._undo.record(
         buildUndoEntry(
           buildHistoryChangeSet(result.changes),
           result.__beforeSnap,
           result.__beforeLinks,
           created.afterSnap,
-          created.afterLinks
+          created.afterLinks,
+          relativePlacementPinsChanged ? relativePlacementPinsBefore : void 0,
+          relativePlacementPinsChanged ? relativePlacementPinsAfter : void 0
         ),
         computeCoalesceKey(action),
         Date.now()
@@ -20773,17 +21741,20 @@ var ScheduleCore = class {
     }
     if (result.ok) {
       if (historyPolicy === "clear-on-success") {
-        this._saveTracker.snapshotActivities(
-          this.coreRuntime.state.getAllActivities()
+        this._saveTracker.acknowledge(
+          this.coreRuntime.state.getAllActivities(),
+          this.coreRuntime.state.getAllLinks()
         );
-        this._saveTracker.snapshotLinks(this.getAllLinksView());
         this._undo.clear();
       } else if (action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true) {
         this._saveTracker.acknowledgePersistedLookahead(
-          action.activityIds,
+          result.changes.activities,
           (activityId) => this.coreRuntime.state.getActivity(activityId)
         );
-      } else if (options.preview !== true) {
+        if (action.persistedProgress !== void 0) {
+          this._undo.clear();
+        }
+      } else {
         this._saveTracker.recordChanges(
           result.changes.activities,
           result.changes.links,
@@ -20794,20 +21765,6 @@ var ScheduleCore = class {
     }
     result = this._withReappliedViewState(action, result);
     if (!result.ok) return { result, changedState: false };
-    if (options.preview === true) {
-      const inverse = buildInverseChangeSet(
-        this.coreRuntime.state,
-        buildUndoEntry(buildHistoryChangeSet(result.changes)),
-        "before"
-      );
-      return {
-        result: {
-          ...toPublicDispatchResult(result),
-          preview: { inverse, revision: this._scheduleRevision }
-        },
-        changedState: false
-      };
-    }
     if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
       this._recordScheduleMutation(
         options.skipAutoSchedule !== true && options.skipCriticalPath !== true && resolveRunCriticalPath(action)
@@ -20844,6 +21801,19 @@ var ScheduleCore = class {
     const merged = this._reapplyViewState(result.changes);
     return merged === null ? result : { ...result, changes: merged };
   }
+  _recordRelativePlacementPin(action, changes) {
+    const state = this.coreRuntime.state;
+    if (action.kind !== "activity-create") return;
+    const referenceId = action.afterSiblingId ?? action.beforeSiblingId ?? (action.eventSource === "Creation button (+)" && action.parentId !== ROOT_PARENT_ID ? action.parentId : void 0);
+    if (referenceId === void 0) return;
+    const created = changes.activities.find(({ kind }) => kind === "created");
+    if (created === void 0) return;
+    state.setRelativePlacementPin(created.id, {
+      referenceId,
+      branchParentId: action.parentId,
+      side: action.beforeSiblingId === void 0 ? "after" : "before"
+    });
+  }
   /**
    * The single place the two view-state passes are chained. Dispatch, undo and
    * redo all route through here: when this existed only inside the dispatch
@@ -20866,39 +21836,7 @@ var ScheduleCore = class {
       sequenced.changes ?? withFilter ?? changes,
       sequenced.touchedParents
     );
-    const reapplied = withOrder ?? sequenced.changes ?? withFilter;
-    const finalChanges = reapplied ?? changes;
-    const createdIds = finalChanges.activities.filter((change) => change.kind === "created").map((change) => String(change.id));
-    if (createdIds.length === 0) return reapplied;
-    const createdAndAncestors = new Set(createdIds);
-    const filterProjection = this.coreRuntime.state.getFilterProjection();
-    for (const createdId of createdIds) {
-      if (filterProjection !== null) {
-        filterProjection.pinnedVisibleIds.add(createdId);
-      }
-      let activityId = createdId;
-      while (activityId !== null && activityId !== ROOT_PARENT_ID) {
-        createdAndAncestors.add(activityId);
-        if (filterProjection !== null) {
-          filterProjection.visibleIds.add(activityId);
-          filterProjection.visibleReferenceCounts.set(
-            activityId,
-            (filterProjection.visibleReferenceCounts.get(activityId) ?? 0) + 1
-          );
-        }
-        activityId = this.coreRuntime.state.getParentId(activityId);
-      }
-    }
-    const createdVisibility = applyVisibleSet(
-      this.coreRuntime.state,
-      createdAndAncestors,
-      createdAndAncestors
-    );
-    if (createdVisibility.length === 0) return reapplied;
-    return {
-      ...finalChanges,
-      viewState: [...finalChanges.viewState ?? [], ...createdVisibility]
-    };
+    return withOrder ?? sequenced.changes ?? withFilter;
   }
   /**
    * Emits `order` for the branches this mutation resequenced, when no user order
@@ -20977,16 +21915,22 @@ var ScheduleCore = class {
       context
     );
     const changedActivities = changesRequireFilterProjectionRebuild(changes) ? null : collectChangedActivities(changes, adapter);
+    const relativePlacementPins = adapter.getRelativePlacementPins();
     let affectedIds;
     let visibleIds;
-    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent;
+    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent || changesAffectRelativePinProjection(
+      changes,
+      changedActivities,
+      adapter,
+      relativePlacementPins
+    );
     if (needsProjectionRebuild) {
       const rebuiltProjection = buildFilterProjection({
         activities: adapter.getAllActivities(),
         parentOf: (activityId) => adapter.getParentId(activityId),
         filter,
         context,
-        ...projectionIsCurrent ? { pinnedVisibleIds: projection.pinnedVisibleIds } : {}
+        relativePlacementPins
       });
       adapter.setFilterProjection(rebuiltProjection);
       visibleIds = rebuiltProjection.visibleIds;
@@ -21060,13 +22004,20 @@ var ScheduleCore = class {
         this.coreRuntime.customIdTracker.beginCustomIdTransaction();
         let changes;
         try {
-          for (const [activityId, fields] of calculatedFields) {
+          for (const [activityId, fields] of calculatedFields.activities) {
             setCriticalPathFieldsIfChanged(
               this.coreRuntime.state,
               activityId,
               fields
             );
           }
+          for (const [linkId, fields] of calculatedFields.links) {
+            setCriticalPathLinkFieldsIfChanged(
+              this.coreRuntime.state,
+              linkId,
+              fields
+            );
+          }
           changes = await assembleChangeSet(this.coreRuntime.state, {
             source: { kind: "init" },
             beforeSnap: /* @__PURE__ */ new Map(),
@@ -21348,7 +22299,6 @@ var DISPATCH_ACTION_KIND = {
   FILTER_SET: "filter-set",
   SORT_SET: "sort-set",
   SIR_SYNC: "sir-sync",
-  SIR_APPROVE: "sir-approve",
   ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
 };
 var KIND_CATALOG_COVERS_UNION = {
@@ -21378,7 +22328,6 @@ var KIND_CATALOG_COVERS_UNION = {
   [DISPATCH_ACTION_KIND.FILTER_SET]: true,
   [DISPATCH_ACTION_KIND.SORT_SET]: true,
   [DISPATCH_ACTION_KIND.SIR_SYNC]: true,
-  [DISPATCH_ACTION_KIND.SIR_APPROVE]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC]: true
 };
 var DISPATCH_ACTION_KINDS = Object.keys(KIND_CATALOG_COVERS_UNION);