@outbuild-company/schedule-core 1.6.3 → 1.8.0

package/dist/index.cjs

@@ -134,6 +134,9 @@ var REJECTION_REASON = {
   ACTIVITY_NOT_FOUND: "activity_not_found",
   PARENT_NOT_FOUND: "parent_not_found",
   ACTIVITY_IDS_EMPTY: "activity_ids_empty",
+  NO_ACTIVITY_SELECTION: "no_activity_selection",
+  CLIPBOARD_EMPTY: "clipboard_empty",
+  ACTIVITY_PASTE_INVARIANT_FAILED: "activity_paste_invariant_failed",
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
@@ -141,6 +144,8 @@ var REJECTION_REASON = {
   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"
 };
 
@@ -269,8 +274,17 @@ function toDays(hours, hoursPerDay) {
   return hours / hoursPerDay;
 }
 function calendarDaySpan(startDate, endDate) {
-  const elapsed = endDate.getTime() - startDate.getTime();
-  return Math.floor(elapsed / MILLISECONDS_PER_DAY) + 1;
+  const startDay = Date.UTC(
+    startDate.getUTCFullYear(),
+    startDate.getUTCMonth(),
+    startDate.getUTCDate()
+  );
+  const endDay = Date.UTC(
+    endDate.getUTCFullYear(),
+    endDate.getUTCMonth(),
+    endDate.getUTCDate()
+  );
+  return Math.floor((endDay - startDay) / MILLISECONDS_PER_DAY) + 1;
 }
 var FIELD_REGISTRY = {
   name: { valueKind: "string", extract: (activity) => activity.name },
@@ -285,7 +299,10 @@ var FIELD_REGISTRY = {
   },
   uniqueCorrelativeId: {
     valueKind: "number",
-    extract: (activity) => Number(activity.uniqueCorrelativeId)
+    extract: (activity) => {
+      const value = Number(activity.uniqueCorrelativeId);
+      return Number.isFinite(value) ? value : null;
+    }
   },
   progress: { valueKind: "number", extract: (activity) => activity.progress },
   durationDays: {
@@ -294,7 +311,7 @@ var FIELD_REGISTRY = {
   },
   calendarDuration: {
     valueKind: "number",
-    extract: (activity) => calendarDaySpan(activity.startDate, activity.endDate)
+    extract: (activity) => activity.type === "milestone" ? 0 : calendarDaySpan(activity.startDate, activity.endDate)
   },
   cost: { valueKind: "number", extract: (activity) => activity.cost },
   usedCost: { valueKind: "number", extract: (activity) => activity.usedCost },
@@ -660,34 +677,102 @@ var OPERATORS_BY_KIND = {
   boolean: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
   reference: /* @__PURE__ */ new Set(["someOf", "notSomeOf"])
 };
-function validateCriterion(criterion) {
+function normalizeDateRange(value) {
+  if (value === void 0) return { ok: true, dateRange: void 0 };
+  if (typeof value !== "object" || value === null) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  const { start, end } = value;
+  if (!(start instanceof Date) || !(end instanceof Date)) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  const startTime = start.getTime();
+  const endTime = end.getTime();
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime > endTime) {
+    return { ok: false, reason: "invalid_value" };
+  }
+  return {
+    ok: true,
+    dateRange: { start: new Date(startTime), end: new Date(endTime) }
+  };
+}
+function normalizeCriterion(criterion) {
   const descriptor = getFieldDescriptor(criterion.field);
-  if (descriptor === null) return "unknown_field";
+  if (descriptor === null) return { ok: false, reason: "unknown_field" };
   if (!OPERATORS_BY_KIND[descriptor.valueKind].has(criterion.operator)) {
-    return "unknown_operator";
+    return { ok: false, reason: "unknown_operator" };
+  }
+  if (descriptor.valueKind === "number") {
+    const value = normalizeNumberValue(criterion.value);
+    return value === null ? { ok: false, reason: "invalid_value" } : {
+      ok: true,
+      criterion: { ...criterion, value }
+    };
+  }
+  if (descriptor.valueKind === "date") {
+    const value = normalizeDateValue(criterion.value);
+    return value === null ? { ok: false, reason: "invalid_value" } : {
+      ok: true,
+      criterion: { ...criterion, value }
+    };
+  }
+  const rejection = validateValueForKind(criterion, descriptor.valueKind);
+  if (rejection !== null) return { ok: false, reason: rejection };
+  if (descriptor.valueKind === "boolean") {
+    return {
+      ok: true,
+      criterion: {
+        ...criterion,
+        value: [...new Set(criterion.value)]
+      }
+    };
+  }
+  if (descriptor.valueKind === "id-array" || descriptor.valueKind === "enum" || descriptor.valueKind === "reference") {
+    return {
+      ok: true,
+      criterion: {
+        ...criterion,
+        value: [
+          ...new Set(
+            criterion.value.map(String)
+          )
+        ]
+      }
+    };
   }
-  return validateValueForKind(criterion, descriptor.valueKind);
+  return { ok: true, criterion };
 }
 function validateValueForKind(criterion, valueKind) {
   const { value } = criterion;
-  if (valueKind === "id-array" || valueKind === "enum") {
-    return Array.isArray(value) ? null : "invalid_value";
-  }
-  if (Array.isArray(value)) return "invalid_value";
-  if (valueKind === "number") {
-    return Number.isFinite(Number(value)) ? null : "invalid_value";
+  if (valueKind === "boolean") {
+    return Array.isArray(value) && value.every((item) => typeof item === "boolean") ? null : "invalid_value";
   }
-  if (valueKind === "date") {
-    return isValidDateValue(value) ? null : "invalid_value";
+  if (valueKind === "id-array" || valueKind === "enum" || valueKind === "reference") {
+    return Array.isArray(value) && value.every(
+      (item) => typeof item === "string" || typeof item === "number"
+    ) ? null : "invalid_value";
   }
+  if (Array.isArray(value)) return "invalid_value";
   return null;
 }
-function isValidDateValue(value) {
-  if (value instanceof Date) return true;
-  if (typeof value === "string" || typeof value === "number") {
-    return !Number.isNaN(new Date(value).getTime());
-  }
-  return false;
+function normalizeNumberValue(value) {
+  if (typeof value === "string" && value.trim() === "") return null;
+  if (typeof value !== "string" && typeof value !== "number") return null;
+  const parsed2 = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed2) ? parsed2 : null;
+}
+function normalizeDateValue(value) {
+  let date2;
+  if (value instanceof Date) date2 = new Date(value.getTime());
+  else if (typeof value === "string") date2 = new Date(value);
+  else if (typeof value === "number") date2 = new Date(value);
+  else return null;
+  return Number.isFinite(date2.getTime()) ? date2 : null;
+}
+
+// src/shared/clone-domain-value.ts
+function cloneDomainValue(value) {
+  return structuredClone(value);
 }
 
 // src/dispatch/filter.ts
@@ -717,15 +802,21 @@ function resolveFilter(adapter, filter, hoursPerDay) {
 }
 function dispatchFilterSet(action, deps) {
   const { adapter, hoursPerDay } = deps;
+  const criteria = [];
   for (const criterion of action.criteria) {
-    const rejection = validateCriterion(criterion);
-    if (rejection !== null) return { ok: false, reason: rejection };
-  }
-  const filter = action.dateRange === void 0 ? { criteria: action.criteria, logic: action.logic } : {
-    criteria: action.criteria,
-    logic: action.logic,
-    dateRange: action.dateRange
-  };
+    const result = normalizeCriterion(criterion);
+    if (!result.ok) return { ok: false, reason: result.reason };
+    criteria.push(result.criterion);
+  }
+  const rangeResult = normalizeDateRange(action.dateRange);
+  if (!rangeResult.ok) return { ok: false, reason: rangeResult.reason };
+  const filter = cloneDomainValue(
+    rangeResult.dateRange === void 0 ? { criteria, logic: action.logic } : {
+      criteria,
+      logic: action.logic,
+      dateRange: rangeResult.dateRange
+    }
+  );
   adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
   const { visibleIds, projection } = resolveFilter(
     adapter,
@@ -870,7 +961,7 @@ function dispatchSortSet(action, deps) {
     const rejection = validateRule(rule);
     if (rejection !== null) return { ok: false, reason: rejection };
   }
-  const order = action.rules.length === 0 ? null : { rules: action.rules };
+  const order = action.rules.length === 0 ? null : cloneDomainValue({ rules: action.rules });
   adapter.setActiveOrder(order);
   const changes = {
     source: action,
@@ -1438,6 +1529,11 @@ function isDescendantOf(childId, ancestorId, adapter) {
   }
   return false;
 }
+function isSummaryHierarchyLink(source, target, adapter) {
+  const sourceIsSummary = isSummary2(source, adapter);
+  const targetIsSummary = isSummary2(target, adapter);
+  return targetIsSummary && isDescendantOf(source, target, adapter) || sourceIsSummary && isDescendantOf(target, source, adapter);
+}
 function getLeafDescendants(parentId, adapter) {
   const leaves = [];
   const stack = [parentId];
@@ -1696,6 +1792,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,
@@ -2375,6 +2473,18 @@ var noopReporter = {
   }
 };
 
+// src/internal/state/calendar-duration.ts
+var CALENDAR_DAY_MS = 864e5;
+function computeCalendarDuration(activity) {
+  if (activity.type === "milestone") return 0;
+  const start = activity.startDate?.getTime();
+  const end = activity.endDate?.getTime();
+  if (start == null || end == null || Number.isNaN(start) || Number.isNaN(end)) {
+    return null;
+  }
+  return Math.floor((end - start) / CALENDAR_DAY_MS) + 1;
+}
+
 // src/autoscheduler/integration/apply-results.ts
 function applyResults(adapter, result) {
   if (result.cancelled || result.updatedIds.length === 0) return;
@@ -2386,6 +2496,7 @@ function applyResults(adapter, result) {
       if (!liveActivity) continue;
       liveActivity.startDate = plan.startDate;
       liveActivity.endDate = plan.endDate;
+      liveActivity.calendarDuration = computeCalendarDuration(liveActivity);
       adapter.updateActivity(id);
     }
   });
@@ -2452,13 +2563,253 @@ function hasPath(adjacency, from, to) {
   return false;
 }
 
+// src/internal/dependency-graph/strongly-connected-components.ts
+function circularComponents(edges) {
+  const walk = buildWalkState(edges);
+  for (const node of walk.adjacency.keys()) {
+    if (!walk.records.has(node)) collectFromRoot(node, walk);
+  }
+  return walk.components;
+}
+function buildWalkState(edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const selfLooped = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const source = String(edge.source);
+    const target = String(edge.target);
+    const sourceNeighbors = neighborsOf(adjacency, source);
+    neighborsOf(adjacency, target);
+    if (source === target) {
+      selfLooped.add(source);
+      continue;
+    }
+    sourceNeighbors.push(target);
+  }
+  return {
+    adjacency,
+    selfLooped,
+    records: /* @__PURE__ */ new Map(),
+    componentStack: [],
+    nextIndex: 0,
+    components: []
+  };
+}
+function neighborsOf(adjacency, node) {
+  const existing = adjacency.get(node);
+  if (existing) return existing;
+  const created = [];
+  adjacency.set(node, created);
+  return created;
+}
+function collectFromRoot(root, walk) {
+  const frames = [];
+  frames.push({ node: root, record: enterNode(root, walk), neighborCursor: 0 });
+  while (frames.length > 0) {
+    const frame = frames[frames.length - 1];
+    if (frame === void 0) break;
+    const neighbors = walk.adjacency.get(frame.node) ?? [];
+    if (frame.neighborCursor < neighbors.length) {
+      const neighbor = neighbors[frame.neighborCursor];
+      frame.neighborCursor += 1;
+      if (neighbor === void 0) continue;
+      visitNeighbor(frame, neighbor, frames, walk);
+      continue;
+    }
+    frames.pop();
+    const parentFrame = frames[frames.length - 1];
+    if (parentFrame && frame.record.lowLink < parentFrame.record.lowLink) {
+      parentFrame.record.lowLink = frame.record.lowLink;
+    }
+    const isComponentRoot = frame.record.lowLink === frame.record.visitIndex;
+    if (isComponentRoot) emitComponent(frame.node, walk);
+  }
+}
+function visitNeighbor(frame, neighbor, frames, walk) {
+  const neighborRecord = walk.records.get(neighbor);
+  if (!neighborRecord) {
+    frames.push({
+      node: neighbor,
+      record: enterNode(neighbor, walk),
+      neighborCursor: 0
+    });
+    return;
+  }
+  const lowersCurrent = neighborRecord.onStack && neighborRecord.visitIndex < frame.record.lowLink;
+  if (lowersCurrent) frame.record.lowLink = neighborRecord.visitIndex;
+}
+function enterNode(node, walk) {
+  const record = {
+    visitIndex: walk.nextIndex,
+    lowLink: walk.nextIndex,
+    onStack: true
+  };
+  walk.nextIndex += 1;
+  walk.records.set(node, record);
+  walk.componentStack.push({ node, record });
+  return record;
+}
+function emitComponent(rootNode, walk) {
+  const component = [];
+  for (; ; ) {
+    const entry = walk.componentStack.pop();
+    if (entry === void 0) break;
+    entry.record.onStack = false;
+    component.push(entry.node);
+    if (entry.node === rootNode) break;
+  }
+  const firstMember = component[0];
+  const isSingleSelfLoop = component.length === 1 && firstMember !== void 0 && walk.selfLooped.has(firstMember);
+  const isCircular = component.length > 1 || isSingleSelfLoop;
+  if (isCircular) walk.components.push(component);
+}
+
+// src/internal/dependency-graph/effective-graph.ts
+function projectEffectiveEdges(port, links, proposal) {
+  const projectionPort = proposal ? new ReparentedPort(port, proposal) : port;
+  return expandParentLinks([...links], projectionPort);
+}
+var ReparentedPort = class {
+  constructor(base, proposal) {
+    this.base = base;
+    for (const [childId, proposedParent] of proposal.reparented) {
+      const childKey = String(childId);
+      const newParent = proposedParent === null || isRootParent(proposedParent) ? null : proposedParent;
+      const oldParent = base.getActivity(childId)?.parentId ?? null;
+      const oldKey = oldParent === null || isRootParent(oldParent) ? null : String(oldParent);
+      const newKey = newParent === null ? null : String(newParent);
+      if (oldKey === newKey) continue;
+      this.reparented.set(childKey, newParent);
+      if (oldKey !== null) {
+        const removed = this.movedOutByParent.get(oldKey) ?? /* @__PURE__ */ new Set();
+        removed.add(childKey);
+        this.movedOutByParent.set(oldKey, removed);
+      }
+      if (newKey !== null) {
+        const gained = this.movedInByParent.get(newKey) ?? [];
+        gained.push(childId);
+        this.movedInByParent.set(newKey, gained);
+      }
+    }
+  }
+  base;
+  reparented = /* @__PURE__ */ new Map();
+  movedOutByParent = /* @__PURE__ */ new Map();
+  movedInByParent = /* @__PURE__ */ new Map();
+  withOverride(activity) {
+    if (!activity) return null;
+    const override = this.reparented.get(String(activity.id));
+    if (override === void 0) return activity;
+    return { ...activity, parentId: override };
+  }
+  getActivity(activityId) {
+    return this.withOverride(this.base.getActivity(activityId));
+  }
+  getLiveActivity(activityId) {
+    return this.withOverride(this.base.getLiveActivity(activityId));
+  }
+  getAllActivities() {
+    return this.base.getAllActivities().map((activity) => this.withOverride(activity) ?? activity);
+  }
+  getChildren(parentId) {
+    const parentKey = String(parentId);
+    const removed = this.movedOutByParent.get(parentKey);
+    const baseChildren = this.base.getChildren(parentId);
+    const kept = removed ? baseChildren.filter((childId) => !removed.has(String(childId))) : [...baseChildren];
+    const gained = this.movedInByParent.get(parentKey);
+    if (gained) kept.push(...gained);
+    return kept;
+  }
+  getParent(activityId) {
+    const override = this.reparented.get(String(activityId));
+    if (override === void 0) return this.base.getParent(activityId);
+    if (override === null) return null;
+    return this.getActivity(override);
+  }
+  isChildOf(childId, parentId) {
+    const targetKey = String(parentId);
+    const visited = /* @__PURE__ */ new Set();
+    let current = this.getActivity(childId);
+    while (current) {
+      const parent = current.parentId;
+      if (parent === null || isRootParent(parent)) return false;
+      const parentKey = String(parent);
+      if (parentKey === targetKey) return true;
+      if (visited.has(parentKey)) return false;
+      visited.add(parentKey);
+      current = this.getActivity(parent);
+    }
+    return false;
+  }
+  getAllLinks() {
+    return this.base.getAllLinks();
+  }
+  getAllIds() {
+    return this.base.getAllIds();
+  }
+  getLink(linkId) {
+    return this.base.getLink(linkId);
+  }
+  activityExists(activityId) {
+    return this.base.activityExists(activityId);
+  }
+  getOutgoingLinkIds(activityId) {
+    return this.base.getOutgoingLinkIds(activityId);
+  }
+  getIncomingLinkIds(activityId) {
+    return this.base.getIncomingLinkIds(activityId);
+  }
+  getClosestWorkTime(params) {
+    return this.base.getClosestWorkTime(params);
+  }
+  calculateEndDate(params) {
+    return this.base.calculateEndDate(params);
+  }
+  calculateDuration(params) {
+    return this.base.calculateDuration(params);
+  }
+  batchUpdate(runBatch) {
+    this.base.batchUpdate(runBatch);
+  }
+  updateActivity(activityId) {
+    this.base.updateActivity(activityId);
+  }
+  getFlags() {
+    return this.base.getFlags();
+  }
+  getProjectEnd() {
+    return this.base.getProjectEnd();
+  }
+};
+
+// src/internal/dependency-graph/effective-graph-validation.ts
+function validateTopologyCommit(input) {
+  const { port, currentLinks, proposedLinks, proposal } = input;
+  const proposedEdges = projectEffectiveEdges(port, proposedLinks, proposal);
+  if (!hasDirectedCycle(proposedEdges)) return { ok: true };
+  const currentEdges = projectEffectiveEdges(port, currentLinks);
+  const corruptBefore = corruptActivityIds(currentEdges);
+  const corruptAfter = corruptActivityIds(proposedEdges);
+  const newlyCyclicActivityIds = [...corruptAfter].filter(
+    (activityId) => !corruptBefore.has(activityId)
+  );
+  if (newlyCyclicActivityIds.length === 0) return { ok: true };
+  return { ok: false, newlyCyclicActivityIds };
+}
+function corruptActivityIds(edges) {
+  const corrupt = /* @__PURE__ */ new Set();
+  for (const component of circularComponents(edges)) {
+    for (const activityId of component) corrupt.add(activityId);
+  }
+  return corrupt;
+}
+
 // src/autoscheduler/links/apply-link-operation.ts
 function applyLinkOperation(op, deps) {
   switch (op.kind) {
     case "create":
       return applyCreate(op, deps);
     case "update":
-      return applyUpdate(op, deps);
+      return applyLinkUpdate(op, deps.port);
     case "delete":
       return applyDelete(op, deps);
   }
@@ -2484,6 +2835,10 @@ function applyLinkCreates(links, deps) {
       rejected = { applied: false, rejected: "activity-missing" };
       break;
     }
+    if (isSummaryHierarchyLink(operation.source, operation.target, deps.port)) {
+      rejected = { applied: false, rejected: "hierarchy-link" };
+      break;
+    }
     const key = linkKey(operation);
     const duplicateId = duplicateKeys.get(key);
     if (duplicateId !== void 0) {
@@ -2509,6 +2864,26 @@ function applyLinkCreates(links, deps) {
     return { applied: false, rejected: "cycle" };
   }
   if (rejected) return rejected;
+  const proposedLinks = [
+    ...existingLinks,
+    ...links.map(({ operation, linkId }) => ({
+      id: linkId,
+      source: operation.source,
+      target: operation.target,
+      type: operation.type,
+      lag: operation.lag,
+      freeSlackHours: null,
+      isCritical: false
+    }))
+  ];
+  const effectiveVerdict = validateTopologyCommit({
+    port: deps.port,
+    currentLinks: existingLinks,
+    proposedLinks
+  });
+  if (!effectiveVerdict.ok) {
+    return { applied: false, rejected: "cycle" };
+  }
   for (const { operation, linkId } of links) {
     const preserved = deps.preserved?.get(linkId);
     deps.port.addLink({
@@ -2517,6 +2892,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 }
@@ -2537,6 +2914,9 @@ function applyCreate(op, deps) {
   if (!src || !tgt) {
     return { applied: false, rejected: "activity-missing" };
   }
+  if (isSummaryHierarchyLink(op.source, op.target, port)) {
+    return { applied: false, rejected: "hierarchy-link" };
+  }
   const existingLinks = port.getAllLinks();
   for (const l of existingLinks) {
     if (String(l.source) === String(op.source) && String(l.target) === String(op.target) && l.type === op.type) {
@@ -2556,13 +2936,22 @@ 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,
+    currentLinks: existingLinks,
+    proposedLinks: [...existingLinks, link]
+  });
+  if (!effectiveVerdict.ok) {
+    return { applied: false, rejected: "cycle" };
+  }
   port.addLink(link);
   return { applied: true, linkId: id };
 }
-function applyUpdate(op, deps) {
-  const { port } = deps;
+function applyLinkUpdate(op, port) {
   const link = port.getLink(op.linkId);
   if (!link) return { applied: false, rejected: "link-missing" };
   if (op.lag !== void 0) port.setLinkField(op.linkId, "lag", op.lag);
@@ -2733,6 +3122,10 @@ function diffOutgoingLinks(input) {
 }
 
 // src/autoscheduler/links/lag-units.ts
+function roundLagDays(lagDays) {
+  const rounded = Math.sign(lagDays) * Math.round(Math.abs(lagDays));
+  return Object.is(rounded, -0) ? 0 : rounded;
+}
 function lagDaysToHours(lagDays, hoursPerDay) {
   return Math.sign(lagDays) * Math.round(Math.abs(lagDays) * hoursPerDay);
 }
@@ -2995,10 +3388,7 @@ function adjustLinkLagOnTaskMove(targetId, adapter, preEditTarget) {
       calendarApi
     );
     if (newLag === link.lag) continue;
-    applyLinkOperation(
-      { kind: "update", linkId: link.id, lag: newLag },
-      { port: adapter }
-    );
+    applyLinkUpdate({ linkId: link.id, lag: newLag }, adapter);
   }
 }
 
@@ -3062,19 +3452,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;
@@ -3305,7 +3720,7 @@ var setEndDate = (value) => ({
 
 // src/columns/shared/date-normalize.ts
 function truncateToUtcDay(date2, tz) {
-  if (tz) {
+  {
     const parts = new Intl.DateTimeFormat("en-CA", {
       timeZone: tz,
       year: "numeric",
@@ -3315,9 +3730,6 @@ function truncateToUtcDay(date2, tz) {
     const get = (kind) => Number(parts.find((p) => p.type === kind)?.value);
     return new Date(Date.UTC(get("year"), get("month") - 1, get("day")));
   }
-  return new Date(
-    Date.UTC(date2.getFullYear(), date2.getMonth(), date2.getDate())
-  );
 }
 function endOfLocalDay(date2, tz) {
   {
@@ -3327,11 +3739,11 @@ function endOfLocalDay(date2, tz) {
   }
 }
 function nextWorkingDay(calendar, domainDay) {
-  let cursor = truncateToUtcDay(domainDay);
+  let cursor = truncateToUtcDay(domainDay, "UTC");
   while (!calendar.isWorkTime(cursor, CALENDAR_UNIT.DAY)) {
     cursor = new Date(cursor);
     cursor.setUTCDate(cursor.getUTCDate() + 1);
-    cursor = truncateToUtcDay(cursor);
+    cursor = truncateToUtcDay(cursor, "UTC");
   }
   return cursor;
 }
@@ -3369,11 +3781,12 @@ var DATELESS_CONSTRAINTS = /* @__PURE__ */ new Set([
 ]);
 var IMPLIED_CONSTRAINT_ON_DATE_EDIT = "snet";
 function normalizeConstraintDate(typedDay, calendar, constraintType) {
+  const constraintDay = truncateToUtcDay(typedDay, "UTC");
   if (!START_BASED_CONSTRAINTS2.has(constraintType) && !END_BASED_CONSTRAINTS.has(constraintType)) {
-    return typedDay;
+    return constraintDay;
   }
-  const reference = START_BASED_CONSTRAINTS2.has(constraintType) ? shiftStart(calendar, typedDay) : shiftEnd(calendar, typedDay);
-  const result = new Date(typedDay);
+  const reference = START_BASED_CONSTRAINTS2.has(constraintType) ? shiftStart(calendar, constraintDay) : shiftEnd(calendar, constraintDay);
+  const result = new Date(constraintDay);
   result.setUTCHours(
     reference.getUTCHours(),
     reference.getUTCMinutes(),
@@ -3429,10 +3842,8 @@ var durationPipeline = {
   },
   parseInput(rawValue, _activity, ctx) {
     const numericValue = parseFloat(String(rawValue));
-    if (Number.isNaN(numericValue)) return parseError("not_a_number");
-    return parsed(
-      ctx.inputUnit === "hours" ? numericValue : durationToHours(numericValue, ctx.hoursPerDay)
-    );
+    if (!Number.isFinite(numericValue)) return parseError("not_a_number");
+    return parsed(durationToHours(numericValue, ctx.hoursPerDay));
   },
   validate(_activity, oldValue, newValue) {
     if (isNegativeDuration(newValue)) {
@@ -3881,17 +4292,7 @@ var startDatePipeline = {
   transform(activity, newValue, ctx) {
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
     if (!calendar) {
-      return fieldChanges(
-        {
-          startDate: newValue,
-          ...setConstraintTypeImplied(),
-          ...setConstraintDate(newValue)
-        },
-        {
-          autoSchedule: true,
-          postProcessors: ["adjustLinkLagOnTaskMove"]
-        }
-      );
+      throw new Error("startDatePipeline: no calendar resolved (integrity)");
     }
     const finalStart = shiftStart(calendar, newValue);
     const milestoneActivity = activity.type === "milestone";
@@ -3921,7 +4322,7 @@ function checkParentStartConstraint(activity, newDate, ctx) {
     activity.id
   );
   if (!parentStartDate) return null;
-  const parentDay = truncateToUtcDay(parentStartDate);
+  const parentDay = truncateToUtcDay(parentStartDate, "UTC");
   if (newDate.getTime() < parentDay.getTime()) {
     return invalid("before_parent_start");
   }
@@ -3969,7 +4370,6 @@ var endDatePipeline = {
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
     if (!calendar) return parsed(day);
     if (!calendar.isWorkTime(day, CALENDAR_UNIT.DAY)) {
-      if (ctx.dateFormat.split(" ").length > 1) return parsed(day);
       return parsed(
         calendar.getClosestWorkTime({
           direction: "past",
@@ -4152,7 +4552,12 @@ var constraintDatePipeline = {
   transform(activity, newValue, ctx) {
     const finalType = isUnconstrained(activity) ? IMPLIED_CONSTRAINT_ON_DATE_EDIT : effectiveConstraintType(activity);
     const calendar = ctx.calendars.getCalendar(activity.calendarId);
-    const storedDate = calendar ? normalizeConstraintDate(newValue, calendar, finalType) : newValue;
+    if (!calendar) {
+      throw new Error(
+        "constraintDatePipeline: no calendar resolved (integrity)"
+      );
+    }
+    const storedDate = normalizeConstraintDate(newValue, calendar, finalType);
     const patch = buildConstraintDateExtraFields(activity, storedDate);
     return fieldChanges(patch, {
       autoSchedule: true
@@ -4452,6 +4857,31 @@ var COLUMN_WRITABLE_FIELDS = new Set(
   COLUMN_WRITABLE_FIELD_LIST
 );
 
+// src/constants/activity-properties.ts
+var ACTIVITY_PROPERTY = {
+  PARENT: "parentId",
+  TYPE: "type",
+  START_DATE: "startDate",
+  END_DATE: "endDate",
+  CONSTRAINT_TYPE: "constraintType",
+  CONSTRAINT_DATE: "constraintDate",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "usedCost",
+  REAL_COST: "realCost",
+  WORK_HOURS: "workHours",
+  REAL_WORK_HOURS: "realWorkHours",
+  CORRELATIVE_ID: "correlativeId",
+  CUSTOM_ID: "customId",
+  NEW_ACTIVITIES_ARRAY: "newActivityIds",
+  HAS_NEW_ACTIVITIES: "hasNewActivities",
+  CALENDAR_DURATION: "calendarDuration"};
+var LINK_PROPERTY = {
+  TYPE: "type",
+  LAG: "lag",
+  FREE_SLACK_HOURS: "freeSlackHours",
+  IS_CRITICAL: "isCritical"};
+
 // src/internal/state/dynamic-writes.ts
 function setActivityFieldDynamic(state, activityId, field, value) {
   state.setActivityFieldDynamic(activityId, field, value);
@@ -4503,11 +4933,6 @@ function cloneCriticalPath(value) {
   };
 }
 
-// src/shared/clone-domain-value.ts
-function cloneDomainValue(value) {
-  return structuredClone(value);
-}
-
 // src/dispatch/shared/snapshots.ts
 var YIELD_EVERY_N_ENTRIES = 200;
 function collectTouchedIds(primary, changes) {
@@ -4619,6 +5044,7 @@ function diffActivity(before, after) {
   const beforeRec = before ?? {};
   const afterRec = after;
   const keys = /* @__PURE__ */ new Set([...Object.keys(beforeRec), ...Object.keys(afterRec)]);
+  keys.delete(ACTIVITY_PROPERTY.CALENDAR_DURATION);
   for (const k of keys) {
     if (Object.hasOwn(beforeRec, k) !== Object.hasOwn(afterRec, k) || !fieldValueEqual(beforeRec[k], afterRec[k])) {
       fields[k] = {
@@ -5310,10 +5736,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(
@@ -5358,6 +5785,10 @@ var CalculateForwardParentsWithLinks = class {
         continue;
       }
       if (calculation) {
+        this.linkCandidates?.set(linkedActivity.linkId, {
+          targetId: String(this.activity.id),
+          ...calculation
+        });
         calculations.push(calculation);
       }
     }
@@ -5805,7 +6236,8 @@ function parentWithLinks(params) {
     linkDirection,
     calculations,
     gantt,
-    direction
+    direction,
+    linkCandidates
   } = params;
   const linksArray = parent[linkProperty];
   const parentData = extractParentData(parent);
@@ -5820,7 +6252,8 @@ function parentWithLinks(params) {
     calculation = new forward_default(
       linksWithActivityData,
       parent,
-      gantt
+      gantt,
+      linkCandidates
     );
     calculation = calculation.calculate();
   } else {
@@ -5865,6 +6298,7 @@ function getLinksWithActivityDataForward(linksArray, linkDirection, calculations
       return null;
     }
     return {
+      linkId: String(linkData.id),
       es: calculationsOfLinkedActivity.es,
       ef: calculationsOfLinkedActivity.ef,
       linkLag: linkData.lag,
@@ -5965,6 +6399,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() {
@@ -6012,7 +6447,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);
@@ -6661,6 +7097,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)) {
@@ -6728,6 +7165,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);
@@ -6899,7 +7337,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)) {
@@ -7165,6 +7608,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();
@@ -7263,7 +7707,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, {
@@ -7281,7 +7726,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) {
@@ -8318,7 +8764,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),
@@ -8326,6 +8771,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())
       );
@@ -8337,8 +8783,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())
       );
@@ -8722,18 +9168,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
       )
     );
   }
@@ -8751,111 +9199,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
@@ -8869,6 +9239,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);
@@ -8882,7 +9255,7 @@ var FreeFloat = class {
     return result;
   }
   parseHoursToDays(date2) {
-    if (!date2) {
+    if (date2 === void 0 || date2 === null) {
       return 0;
     }
     return date2 / this.gantt.config.hoursPerDay;
@@ -8948,6 +9321,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;
@@ -8978,6 +9352,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,
@@ -8997,6 +9378,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();
@@ -9100,14 +9513,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),
@@ -9181,7 +9632,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)
@@ -9191,24 +9643,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: () => {
     }
   };
@@ -9216,21 +9675,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);
-  const forward = maps.forward?.get(activityId);
-  const backward = maps.backward?.get(activityId);
-  const totalSlack = maps.totalFloat.get(activityId) ?? null;
+function fieldsForLink(rawResidual, sourceIsCritical, targetIsCritical, targetProgress) {
+  const freeSlackHours = typeof rawResidual === "number" && Number.isFinite(rawResidual) ? Object.is(rawResidual, -0) ? 0 : rawResidual : null;
   return {
-    criticalPath: {
-      earlyStart: toDate(forward?.es),
+    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 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();
@@ -9243,6 +9773,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);
@@ -9260,61 +9798,36 @@ 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);
+  }
+  for (const [linkId, linkFields] of fields.links) {
+    if (!isCurrent()) return false;
+    setCriticalPathLinkFieldsIfChanged(state, linkId, linkFields);
   }
   return true;
 }
 
-// src/constants/activity-properties.ts
-var ACTIVITY_PROPERTY = {
-  PARENT: "parentId",
-  TYPE: "type",
-  START_DATE: "startDate",
-  END_DATE: "endDate",
-  CONSTRAINT_TYPE: "constraintType",
-  CONSTRAINT_DATE: "constraintDate",
-  PROGRESS: "progress",
-  COST: "cost",
-  USED_COST: "usedCost",
-  REAL_COST: "realCost",
-  WORK_HOURS: "workHours",
-  REAL_WORK_HOURS: "realWorkHours",
-  CORRELATIVE_ID: "correlativeId",
-  CUSTOM_ID: "customId",
-  NEW_ACTIVITIES_ARRAY: "newActivityIds",
-  HAS_NEW_ACTIVITIES: "hasNewActivities"};
-var LINK_PROPERTY = {
-  TYPE: "type",
-  LAG: "lag"};
-
 // src/propagations/upward/real-cost.ts
 function emitRealCost(state) {
   const rootIds = [];
@@ -9367,6 +9880,8 @@ var NON_SCHEDULING_INLINE_COLUMNS = /* @__PURE__ */ new Set([
   COLUMN.TAGS
 ]);
 var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
+  "activity-clipboard-clear",
+  "activity-copy",
   "selection-toggle",
   "selection-replace",
   "visibility-set",
@@ -9380,6 +9895,8 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "status-criteria-set"
 ]);
 var PURE_VIEW_STATE_KINDS = /* @__PURE__ */ new Set([
+  "activity-clipboard-clear",
+  "activity-copy",
   "selection-toggle",
   "selection-replace",
   "visibility-set",
@@ -9408,9 +9925,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
@@ -9696,6 +10219,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);
@@ -9705,7 +10245,8 @@ async function assembleChangeSet(adapter, args) {
     const insertedIds = collectInsertedIds(captured);
     mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
-  const beforeDiffEffects = args.sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
+  const sirDetection = args.sirDetection;
+  const beforeDiffEffects = sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
   const correlativeBefore = buildCorrelativeBeforeMap(
     args.correlativeShifts,
     allTouched
@@ -9716,18 +10257,91 @@ async function assembleChangeSet(adapter, args) {
     allTouched,
     correlativeBefore
   );
-  const effects = args.sirDetection === "after-diff" ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
+  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();
@@ -9763,21 +10377,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 = [];
@@ -10122,6 +10721,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 {
@@ -10154,7 +10773,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 };
@@ -10251,7 +10870,7 @@ async function dispatchInlineEditLinks(action, options, deps) {
   const { specs: specsInDays } = parsePredecessorString(action.newValue);
   const specs = specsInDays.map((spec) => ({
     ...spec,
-    lag: lagDaysToHours(spec.lag, sector.hoursPerDay)
+    lag: lagDaysToHours(roundLagDays(spec.lag), sector.hoursPerDay)
   }));
   const byCorrelative = /* @__PURE__ */ new Map();
   adapter.forEachActivity((a) => {
@@ -10336,26 +10955,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;
@@ -10371,6 +10983,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;
@@ -10588,6 +11234,11 @@ function buildNewActivity(input, adapter) {
     ...base,
     startDate,
     endDate,
+    calendarDuration: computeCalendarDuration({
+      type: base.type,
+      startDate,
+      endDate
+    }),
     newActivityIds: [...base.newActivityIds],
     pendingRequestIds: [...base.pendingRequestIds],
     responsableIds: [...base.responsableIds],
@@ -10738,6 +11389,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;
@@ -10745,7 +11426,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,
@@ -10838,9 +11524,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;
 }
@@ -10919,7 +11614,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;
@@ -11131,7 +11834,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;
@@ -11220,7 +11923,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
   };
@@ -11328,7 +12031,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
   }));
@@ -11400,7 +12103,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);
@@ -11422,7 +12125,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);
@@ -11458,24 +12161,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,
@@ -11498,7 +12215,8 @@ function buildBatchPlan(action, deps) {
       activityId,
       parentId,
       parentBatchId,
-      insertionCorrelativeId
+      insertionCorrelativeId,
+      overrides: normalizedOverrides.get(item.batchId) ?? {}
     });
   }
   const links = [];
@@ -11519,6 +12237,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();
@@ -11628,7 +12370,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,
@@ -11670,180 +12412,299 @@ function stringKeyedLinks(links) {
   return new Map(Array.from(links, ([linkId, link]) => [String(linkId), link]));
 }
 
-// src/dispatch/handlers/activity-paste.ts
-function resolvePasteRootDestination(destination, adapter) {
-  if ("afterSiblingId" in destination) {
-    const sibling = adapter.getActivity(destination.afterSiblingId);
-    if (!sibling) {
-      return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
-    }
-    const parentId2 = sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId);
-    return { ok: true, parentId: parentId2, firstAfter: destination.afterSiblingId };
+// src/dispatch/handlers/sir-sync.ts
+function dispatchSirSync(action, deps) {
+  const { adapter } = deps;
+  const id = action.activityId;
+  const snapshot = adapter.getActivity(id);
+  if (!snapshot) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
   }
-  const parentId = destination.parentId;
-  const siblings = collectSiblings(adapter, parentId).sort(
-    (a, b) => readCorrelativeId(a) - readCorrelativeId(b)
-  );
-  const before = siblings[destination.index]?.id;
-  return { ok: true, parentId, firstBefore: before };
-}
-function applyPasteDomainSemantics(overrides) {
-  const { customId: _customId, ...content } = overrides;
+  const before = snapshot.pendingRequestIds ?? [];
+  const after = action.pendingRequests.map((r) => r.id);
+  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
+  const updated = adapter.getActivity(id);
+  if (!updated) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  const change = {
+    id,
+    kind: "updated",
+    fields: { pendingRequestIds: { before, after } },
+    // ISSUE-025: `after` must be the COMPLETE post-change entity; a partial
+    // object crashes any consumer that projects the full snapshot.
+    after: structuredCloneActivity(updated)
+  };
   return {
-    ...content,
-    progress: 0,
-    ponderator: 0,
-    usedCost: 0,
-    workHours: 0,
-    isLookahead: false
+    ok: true,
+    changes: {
+      source: action,
+      activities: [change],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
   };
 }
-async function dispatchActivityPaste(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  const rootDest = resolvePasteRootDestination(action.destination, adapter);
-  if (!rootDest.ok) return rootDest;
-  const beforeSnap = await snapshotActivities(adapter, /* @__PURE__ */ new Set());
-  const touched = /* @__PURE__ */ new Set();
-  const originalToNew = /* @__PURE__ */ new Map();
-  const createdIds = [];
-  let prevRootId;
-  for (const input of action.activities) {
-    const mappedParent = originalToNew.get(input.originalParentId);
-    let parentId;
-    let afterSiblingId;
-    let beforeSiblingId;
-    if (mappedParent !== void 0) {
-      parentId = mappedParent;
-    } else {
-      parentId = rootDest.parentId;
-      if (prevRootId === void 0) {
-        afterSiblingId = rootDest.firstAfter;
-        beforeSiblingId = rootDest.firstBefore;
-      } else {
-        afterSiblingId = prevRootId;
-      }
+
+// 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)
+  );
+}
+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/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 core = await createActivityCore(
-      {
-        parentId,
-        afterSiblingId,
-        beforeSiblingId,
-        ...input.activityId ? { activityId: input.activityId } : {},
-        overrides: applyPasteDomainSemantics(input.overrides),
-        eventSource: action.eventSource
-      },
-      deps,
-      {
-        skipCorrelativeRecompute: true,
-        skipBeforeSnap: true,
-        customIdReferenceId: action.referenceActivityId
-      }
+  }
+  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}"`
     );
-    if (!core.ok) return core;
-    if (input.baselineSnapshot !== void 0) {
-      const snapshot = input.baselineSnapshot;
-      adapter.setActivityField(
-        core.newId,
-        "baselineSnapshot",
-        snapshot ? {
-          ...snapshot,
-          startDate: snapshot.startDate ? new Date(snapshot.startDate) : null,
-          endDate: snapshot.endDate ? new Date(snapshot.endDate) : null
-        } : null
+  }
+  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 !== 0 && 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 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}"`
       );
     }
-    originalToNew.set(input.originalId, core.newId);
-    createdIds.push(core.newId);
-    if (mappedParent === void 0) prevRootId = core.newId;
+    if (!deps.adapter.getActivity(id)) {
+      throw new Error(
+        `persistence-acknowledge: unknown reconciled activity id "${id}"`
+      );
+    }
+    seen.add(id);
   }
-  const correlativeShifts = recomputeCorrelativeIds(adapter);
-  const createdIdSet = new Set(createdIds.map(String));
-  foldCorrelativeShifts(
-    adapter,
-    correlativeShifts,
-    createdIdSet,
-    beforeSnap,
-    touched
+}
+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))
   );
-  for (const createdId of createdIds) touched.add(String(createdId));
-  const appliedLinks = [];
-  for (const link of action.links) {
-    const newSource = originalToNew.get(link.source);
-    const newTarget = originalToNew.get(link.target);
-    if (newSource === void 0 || newTarget === void 0) continue;
-    const op = {
-      kind: "create",
-      source: newSource,
-      target: newTarget,
-      type: link.type,
-      lag: lagDaysToHours(link.lag, sector.hoursPerDay)
-    };
-    const res = applyLinkOperation(op, {
-      port: adapter,
-      newLinkId: link.linkId ? () => link.linkId : deps.linkIdGen.next
-    });
-    appliedLinks.push({
-      op,
-      finalLinkId: res.applied ? res.linkId : null,
-      rejected: res.applied ? null : res.rejected ?? "link_op_rejected"
-    });
+  const ancestors = findAncestorsOfDirty(deps.adapter, progressIds);
+  const touched = new Set(progressIds);
+  for (const parentId of ancestors) {
+    touched.add(String(parentId));
   }
-  const { scheduledIds } = await runPostMutation(
-    {
-      adapter,
-      scheduler,
-      sector: deps.sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId
-    },
-    {
-      action,
-      autoscheduleFrom: createdIds[0] ?? null,
-      recomputeParentsFrom: createdIds,
-      now: deps.now,
-      options
+  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
+      };
+    },
+    activityOwnerByBackendId
   );
-  const linkChanges = buildLinkChangesForBatch(
-    appliedLinks,
-    /* @__PURE__ */ new Map(),
-    adapter
+  assertValidAssignments(
+    links,
+    "link",
+    (id) => {
+      const link = deps.adapter.getLink(id);
+      return { exists: link !== null, current: link?.proplannerId ?? null };
+    },
+    linkOwnerByBackendId
   );
-  return {
-    ok: true,
-    changes: await assembleChangeSet(adapter, {
-      source: action,
-      beforeSnap,
-      touchedIds: touched,
-      scheduledIds,
-      links: linkChanges,
-      hoursPerDay: sector.hoursPerDay
-    })
-  };
-}
-
-// src/dispatch/handlers/sir-sync.ts
-function dispatchSirSync(action, deps) {
-  const { adapter } = deps;
-  const id = action.activityId;
-  const snapshot = adapter.getActivity(id);
-  if (!snapshot) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
-  }
-  const before = snapshot.pendingRequestIds ?? [];
-  const after = action.pendingRequests.map((r) => r.id);
-  adapter.setActivityField(action.activityId, "pendingRequestIds", after);
-  const change = {
-    id,
-    kind: "updated",
-    fields: { pendingRequestIds: { before, after } },
-    after: { id, pendingRequestIds: after }
-  };
+  assertAllNewEntitiesAcknowledged(currentActivities, activities, "activity");
+  assertAllNewEntitiesAcknowledged(currentLinks, links, "link");
+  const activityChanges = await applyReconciledProgress(
+    reconciledProgress,
+    deps
+  );
+  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: [change],
-      links: [],
+      activities: activityChanges,
+      links: linkChanges,
       calendars: [],
       trackingEvents: []
     }
@@ -11851,8 +12712,15 @@ function dispatchSirSync(action, deps) {
 }
 
 // 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 };
@@ -11892,6 +12760,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: {
@@ -11903,6 +12804,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) {
@@ -11936,6 +12841,37 @@ function isAncestor(descendantId, candidateAncestorId, adapter) {
   return false;
 }
 
+// src/dispatch/shared/hierarchy-cycle-guard.ts
+function reparentClosesEffectiveCycle(adapter, reparented) {
+  const links = adapter.getAllLinks();
+  const verdict = validateTopologyCommit({
+    port: adapter,
+    currentLinks: links,
+    proposedLinks: links,
+    proposal: { reparented }
+  });
+  return !verdict.ok;
+}
+function collectCyclicReparents(planned, adapter) {
+  const cyclic = /* @__PURE__ */ new Set();
+  if (planned.length === 0) return cyclic;
+  const combined = new Map(
+    planned.map((reparent) => [reparent.activityId, reparent.newParentId])
+  );
+  if (!reparentClosesEffectiveCycle(adapter, combined)) return cyclic;
+  const accepted = /* @__PURE__ */ new Map();
+  for (const reparent of planned) {
+    const trial = new Map(accepted);
+    trial.set(reparent.activityId, reparent.newParentId);
+    if (reparentClosesEffectiveCycle(adapter, trial)) {
+      cyclic.add(reparent.activityId);
+      continue;
+    }
+    accepted.set(reparent.activityId, reparent.newParentId);
+  }
+  return cyclic;
+}
+
 // src/dispatch/handlers/activity-move.ts
 async function dispatchActivityMove(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
@@ -11977,6 +12913,17 @@ async function dispatchActivityMove(action, options, deps) {
   const oldParentKey = normalizeParentKey(oldParent);
   const newParentKey = String(action.parentId);
   const parentChanged = oldParentKey !== newParentKey;
+  if (parentChanged) {
+    const reparented = /* @__PURE__ */ new Map([
+      [
+        action.activityId,
+        newParentIsRoot ? null : action.parentId
+      ]
+    ]);
+    if (reparentClosesEffectiveCycle(adapter, reparented)) {
+      return { ok: false, reason: REJECTION_REASON.HIERARCHY_CYCLE };
+    }
+  }
   const touched = /* @__PURE__ */ new Set([action.activityId]);
   if (parentChanged) {
     if (oldParentKey !== ROOT_PARENT_ID) touched.add(oldParentKey);
@@ -12134,21 +13081,14 @@ async function dispatchActivityMove(action, options, deps) {
   };
 }
 
-// src/dispatch/handlers/activity-indent.ts
-async function dispatchActivityIndent(action, options, deps) {
-  const { adapter, scheduler, sector } = deps;
-  scheduler.invalidateAllCaches();
-  if (action.activityIds.length === 0) {
-    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
-  }
-  const selectedSet = new Set(action.activityIds);
-  const touched = /* @__PURE__ */ new Set();
+// src/dispatch/shared/indent-planning.ts
+function planIndentMoves(activityIds, adapter) {
+  const selectedSet = new Set(activityIds);
   const failed = [];
-  const succeededIds = [];
   const moves = [];
   const plannedIds = /* @__PURE__ */ new Set();
   const blockingSet = new Set(selectedSet);
-  const sortedIds = [...action.activityIds].sort((a, b) => {
+  const sortedIds = [...activityIds].sort((a, b) => {
     const aSnap = adapter.getActivity(a);
     const bSnap = adapter.getActivity(b);
     const ac = aSnap ? readCorrelativeId(aSnap) : NOT_SET_SORT_VALUE2;
@@ -12183,12 +13123,43 @@ async function dispatchActivityIndent(action, options, deps) {
     const oldParentId = isRootParent(oldParentRaw) ? ROOT_PARENT_ID : String(oldParentRaw);
     moves.push({ activityId: id, newParentId: targetParentId, oldParentId });
     plannedIds.add(id);
-    touched.add(id);
-    touched.add(targetParentId);
-    if (oldParentId !== ROOT_PARENT_ID) touched.add(oldParentId);
   }
+  const cyclicMoveIds = collectCyclicReparents(moves, adapter);
+  for (const cyclicId of cyclicMoveIds) {
+    failed.push({
+      activityId: cyclicId,
+      reason: REJECTION_REASON.HIERARCHY_CYCLE
+    });
+  }
+  const allowedMoves = moves.filter(
+    (move) => !cyclicMoveIds.has(move.activityId)
+  );
+  return { moves, cyclicMoveIds, allowedMoves, failed };
+}
+
+// src/dispatch/handlers/activity-indent.ts
+async function dispatchActivityIndent(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  scheduler.invalidateAllCaches();
+  if (action.activityIds.length === 0) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
+  }
+  const touched = /* @__PURE__ */ new Set();
+  const succeededIds = [];
+  const plan = planIndentMoves(action.activityIds, adapter);
+  const failed = [
+    ...plan.failed
+  ];
+  for (const move of plan.moves) {
+    touched.add(String(move.activityId));
+    touched.add(String(move.newParentId));
+    if (move.oldParentId !== ROOT_PARENT_ID) {
+      touched.add(String(move.oldParentId));
+    }
+  }
+  const allowedMoves = plan.allowedMoves;
   const beforeSnap = await snapshotActivities(adapter, touched);
-  for (const { activityId, newParentId } of moves) {
+  for (const { activityId, newParentId } of allowedMoves) {
     adapter.setActivityField(activityId, ACTIVITY_PROPERTY.PARENT, newParentId);
     adapter.setActivityField(
       activityId,
@@ -12198,7 +13169,7 @@ async function dispatchActivityIndent(action, options, deps) {
     succeededIds.push(activityId);
   }
   const promotedParents = /* @__PURE__ */ new Set();
-  for (const { activityId, newParentId } of moves) {
+  for (const { activityId, newParentId } of allowedMoves) {
     if (promotedParents.has(newParentId)) continue;
     promotedParents.add(newParentId);
     const newParent = adapter.getActivity(newParentId);
@@ -12250,7 +13221,7 @@ async function dispatchActivityIndent(action, options, deps) {
     releaseClearedCustomId(oldNewParentCustomId, deps.customIdTracker);
   }
   const indentAffectedParents = /* @__PURE__ */ new Set();
-  for (const m of moves) {
+  for (const m of allowedMoves) {
     if (m.oldParentId !== ROOT_PARENT_ID)
       indentAffectedParents.add(m.oldParentId);
     indentAffectedParents.add(m.newParentId);
@@ -12411,8 +13382,24 @@ async function dispatchActivityOutdent(action, options, deps) {
     if (grandparentKey !== ROOT_PARENT_ID) touched.add(String(grandparentKey));
     oldParents.add(oldParentKey);
   }
+  const cyclicPlanIds = collectCyclicReparents(
+    planned.map((plan) => ({
+      activityId: plan.activityId,
+      newParentId: plan.grandparentKey
+    })),
+    adapter
+  );
+  for (const cyclicId of cyclicPlanIds) {
+    failed.push({
+      activityId: cyclicId,
+      reason: REJECTION_REASON.HIERARCHY_CYCLE
+    });
+  }
+  const allowedPlans = planned.filter(
+    (plan) => !cyclicPlanIds.has(plan.activityId)
+  );
   const beforeSnap = await snapshotActivities(adapter, touched);
-  for (const plan of planned) {
+  for (const plan of allowedPlans) {
     adapter.setActivityField(
       plan.activityId,
       ACTIVITY_PROPERTY.PARENT,
@@ -12446,7 +13433,7 @@ async function dispatchActivityOutdent(action, options, deps) {
         task: parentActivity
       }),
       idsRemoved: new Set(
-        planned.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
+        allowedPlans.filter((plan) => plan.oldParentKey === oldParentKey).map((plan) => plan.activityId)
       )
     });
     if (!demotion) {
@@ -12472,7 +13459,7 @@ async function dispatchActivityOutdent(action, options, deps) {
   for (const oldParentKey of oldParents) {
     outdentAffectedParents.add(String(oldParentKey));
   }
-  for (const plan of planned) {
+  for (const plan of allowedPlans) {
     if (plan.grandparentKey !== ROOT_PARENT_ID) {
       outdentAffectedParents.add(String(plan.grandparentKey));
     }
@@ -12560,6 +13547,17 @@ async function dispatchActivitySetProgress(action, options, deps) {
       "[ScheduleCore] progressPipeline not registered \u2014 cannot dispatch activity-set-progress"
     );
   }
+  const editGate = pipeline.canEdit(activitySnap, ctx.hierarchy);
+  if (!editGate.allowed) {
+    const declaredButtonOverride = action.origin === "action-button" && (editGate.reason === "has_lookahead_tasks" || editGate.reason === "summary");
+    if (!declaredButtonOverride) {
+      return {
+        ok: false,
+        reason: editGate.reason,
+        ...editGate.alertKey ? { alertKey: editGate.alertKey } : {}
+      };
+    }
+  }
   const changes = pipeline.transform(
     activitySnap,
     action.newValue,
@@ -12976,171 +13974,29 @@ function syncCustomIdTracker(edit, oldCustomId, deps) {
   const rawValue = liveActivity ? liveActivity.customId : null;
   const newCustomId = typeof rawValue === "string" ? rawValue : null;
   if (oldCustomId !== newCustomId) {
-    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
-  }
-}
-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);
-  }
-  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}"`
-    );
+    deps.customIdTracker.trackCustomIdChange(oldCustomId, newCustomId);
   }
-  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 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 dispatchPersistenceAcknowledge(action, deps) {
-  const activities = action.activities ?? [];
-  const links = action.links ?? [];
-  const activityOwnerByBackendId = /* @__PURE__ */ new Map();
-  for (const activity of deps.adapter.getAllActivities()) {
-    if (activity.proplannerId != null) {
-      activityOwnerByBackendId.set(activity.proplannerId, String(activity.id));
-    }
+function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
+  const missing = /* @__PURE__ */ new Set();
+  for (const candidateId of ids) {
+    if (!beforeSnap.has(candidateId)) missing.add(candidateId);
   }
-  const linkOwnerByBackendId = /* @__PURE__ */ new Map();
-  for (const link of deps.adapter.getAllLinks()) {
-    if (link.proplannerId != null) {
-      linkOwnerByBackendId.set(link.proplannerId, String(link.id));
+  if (missing.size === 0) return;
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
     }
   }
-  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 = [];
-  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/baselines/normalize-baseline-point.ts
@@ -13338,55 +14194,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);
@@ -13490,9 +14297,207 @@ async function dispatchStatusCriteriaSet(action, deps) {
     ok: true,
     changes: await assembleChangeSet(deps.adapter, {
       source: action,
-      beforeSnap,
-      touchedIds: changedIds,
-      scheduledIds: [],
+      beforeSnap,
+      touchedIds: changedIds,
+      scheduledIds: [],
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/activity-copy-paste/policy.ts
+var ACTIVITY_COPY_FIELDS = [
+  "name",
+  "description",
+  "type",
+  "startDate",
+  "durationHours",
+  "constraintType",
+  "constraintDate",
+  "calendarId",
+  "cost",
+  "hasCustomPonderator",
+  "subcontractId",
+  "responsableIds",
+  "tagIds"
+];
+
+// src/activity-copy-paste/copy.ts
+function copyOverrides(activity) {
+  const overrides = {};
+  for (const field of ACTIVITY_COPY_FIELDS) {
+    Object.assign(overrides, { [field]: cloneDomainValue(activity[field]) });
+  }
+  return overrides;
+}
+function selectedInTreeOrder(adapter, selected) {
+  const ordered = [];
+  const visit = (id) => {
+    if (selected.has(String(id))) ordered.push(id);
+    for (const childId of adapter.getChildren(id)) visit(childId);
+  };
+  for (const rootId of adapter.getRootIds()) visit(rootId);
+  return ordered;
+}
+function dispatchActivityCopy(action, deps) {
+  const selected = new Set(deps.adapter.checkedIds().map(String));
+  if (selected.size === 0) {
+    return { ok: false, reason: REJECTION_REASON.NO_ACTIVITY_SELECTION };
+  }
+  const orderedIds = selectedInTreeOrder(deps.adapter, selected);
+  deps.clipboard.value = {
+    activities: orderedIds.map((id) => {
+      const activity = deps.adapter.getActivity(id);
+      if (activity === null)
+        throw new Error(`Selected activity ${id} is missing`);
+      return {
+        originalId: id,
+        originalParentId: activity.parentId ?? "0",
+        overrides: copyOverrides(activity)
+      };
+    }),
+    links: deps.adapter.getAllLinks().filter(
+      (link) => selected.has(String(link.source)) && selected.has(String(link.target))
+    ).map((link) => cloneDomainValue(link))
+  };
+  const selection = dispatchSelectionReplace(
+    { kind: "selection-replace", activityIds: [] },
+    { adapter: deps.adapter }
+  );
+  if (!selection.ok) return selection;
+  return { ...selection, changes: { ...selection.changes, source: action } };
+}
+function dispatchActivityClipboardClear(action, clipboard) {
+  clipboard.value = null;
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: [],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
+  };
+}
+
+// src/activity-copy-paste/paste.ts
+function resolveDestination(afterSiblingId, adapter) {
+  const sibling = adapter.getActivity(afterSiblingId);
+  if (!sibling) {
+    return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
+  }
+  return {
+    ok: true,
+    parentId: sibling.parentId == null ? ROOT_PARENT_ID : String(sibling.parentId)
+  };
+}
+var invariantFailure = () => ({
+  ok: false,
+  reason: REJECTION_REASON.ACTIVITY_PASTE_INVARIANT_FAILED
+});
+async function dispatchActivityPasteCopied(action, options, deps) {
+  const clipboard = deps.activityClipboard.value;
+  if (clipboard === null) {
+    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
+  }
+  const destination = resolveDestination(
+    action.destination.afterSiblingId,
+    deps.adapter
+  );
+  if (!destination.ok) return destination;
+  const beforeSnapshot = await snapshotActivities(
+    deps.adapter,
+    /* @__PURE__ */ new Set()
+  );
+  const touched = /* @__PURE__ */ new Set();
+  const originalToNew = /* @__PURE__ */ new Map();
+  const createdIds = [];
+  let previousRootId;
+  for (const copied of clipboard.activities) {
+    const mappedParent = originalToNew.get(copied.originalParentId);
+    const created = await createActivityCore(
+      {
+        parentId: mappedParent ?? destination.parentId,
+        ...mappedParent === void 0 ? {
+          afterSiblingId: previousRootId ?? action.destination.afterSiblingId
+        } : {},
+        overrides: cloneDomainValue(copied.overrides),
+        eventSource: action.eventSource
+      },
+      deps,
+      {
+        skipCorrelativeRecompute: true,
+        skipBeforeSnap: true,
+        customIdReferenceId: action.destination.afterSiblingId
+      }
+    );
+    if (!created.ok) return created;
+    originalToNew.set(copied.originalId, created.newId);
+    createdIds.push(created.newId);
+    if (mappedParent === void 0) previousRootId = created.newId;
+  }
+  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(createdIds.map(String));
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot,
+    touched
+  );
+  for (const createdId of createdIds) touched.add(String(createdId));
+  const appliedLinks = [];
+  for (const copiedLink of clipboard.links) {
+    const source = originalToNew.get(copiedLink.source);
+    const target = originalToNew.get(copiedLink.target);
+    if (source === void 0 || target === void 0) return invariantFailure();
+    const operation = {
+      kind: "create",
+      source,
+      target,
+      type: copiedLink.type,
+      lag: copiedLink.lag
+    };
+    const result = applyLinkOperation(operation, {
+      port: deps.adapter,
+      newLinkId: deps.linkIdGen.next
+    });
+    if (!result.applied) return invariantFailure();
+    appliedLinks.push({
+      op: operation,
+      finalLinkId: result.linkId,
+      rejected: null
+    });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: createdIds[0] ?? null,
+      recomputeParentsFrom: createdIds,
+      now: deps.now,
+      options
+    }
+  );
+  const linkChanges = buildLinkChangesForBatch(
+    appliedLinks,
+    /* @__PURE__ */ new Map(),
+    deps.adapter
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap: beforeSnapshot,
+      touchedIds: touched,
+      scheduledIds,
+      links: linkChanges,
       hoursPerDay: deps.sector.hoursPerDay
     })
   };
@@ -13500,6 +14505,18 @@ async function dispatchStatusCriteriaSet(action, deps) {
 
 // src/dispatch/dispatch.ts
 async function performDispatch(action, options, deps) {
+  if (action.kind === "activity-copy") {
+    return dispatchActivityCopy(action, {
+      adapter: deps.adapter,
+      clipboard: deps.activityClipboard
+    });
+  }
+  if (action.kind === "activity-clipboard-clear") {
+    return dispatchActivityClipboardClear(action, deps.activityClipboard);
+  }
+  if (action.kind === "activity-paste-copied") {
+    return dispatchActivityPasteCopied(action, options, deps);
+  }
   if (action.kind === "activity-batch") {
     return dispatchActivityBatch(action, options, deps);
   }
@@ -13524,9 +14541,6 @@ async function performDispatch(action, options, deps) {
   if (action.kind === "activity-create") {
     return dispatchActivityCreate(action, options, deps);
   }
-  if (action.kind === "activity-paste") {
-    return dispatchActivityPaste(action, options, deps);
-  }
   if (action.kind === "activity-delete") {
     return dispatchActivityDelete(action, options, deps);
   }
@@ -13570,7 +14584,7 @@ async function performDispatch(action, options, deps) {
     return dispatchSirSync(action, 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);
@@ -16720,7 +17734,7 @@ var ViewStateStore = class {
 };
 
 // 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();
@@ -16742,22 +17756,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());
   }
@@ -16981,6 +18025,7 @@ var ScheduleState = class {
     if (!activity) return;
     this._writeCapture.note(String(activityId), activity);
     activity[field] = value;
+    refreshCalendarDurationIfDateBearing(activity, field);
     if (field === ACTIVITY_PROPERTY.PARENT) this._hierarchy.markDirty();
     if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
   }
@@ -16994,6 +18039,7 @@ var ScheduleState = class {
     }
     this._writeCapture.note(String(activityId), activity);
     Reflect.set(activity, field, coerceActivityFieldValue(field, value));
+    refreshCalendarDurationIfDateBearing(activity, field);
     if (field === ACTIVITY_PROPERTY.PARENT) this._hierarchy.markDirty();
     if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
   }
@@ -17004,6 +18050,7 @@ var ScheduleState = class {
     let reparented = false;
     for (const field of Object.keys(fields)) {
       Reflect.set(activity, field, Reflect.get(fields, field));
+      refreshCalendarDurationIfDateBearing(activity, field);
       if (field === ACTIVITY_PROPERTY.PARENT) reparented = true;
       if (fieldAffectsVisualOrder(field)) this._cache.visualOrderIds = null;
     }
@@ -17013,8 +18060,13 @@ var ScheduleState = class {
     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);
+    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);
@@ -17167,11 +18219,17 @@ 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;
 }
+function refreshCalendarDurationIfDateBearing(activity, field) {
+  if (field !== ACTIVITY_PROPERTY.START_DATE && field !== ACTIVITY_PROPERTY.END_DATE && field !== ACTIVITY_PROPERTY.TYPE) {
+    return;
+  }
+  activity.calendarDuration = computeCalendarDuration(activity);
+}
 function detachLinkRef(refs, linkId) {
   return refs.filter((ref) => String(ref) !== String(linkId));
 }
@@ -17219,15 +18277,7 @@ function readChildren(state, parentId) {
   return out;
 }
 function readChildrenIds(state, parentId) {
-  const key = parentId;
-  if (key === ROOT_PARENT_ID) {
-    const roots = [];
-    state.forEachActivity((activity, id) => {
-      if (isRootParent(activity.parentId)) roots.push(id);
-    });
-    return roots;
-  }
-  return getChildrenInVisualOrder(key, state);
+  return getChildrenInVisualOrder(parentId, state);
 }
 function readSelectedActivityIds(state) {
   return state.checkedIds().map(String);
@@ -17290,8 +18340,7 @@ function buildPipelineContext(adapter, options) {
     activityReader: createStateBackedActivityReader(adapter),
     dateFormat: options.dateFormat ?? "YYYY-MM-DD",
     customHours: options.customHours ?? {},
-    hoursPerDay: options.hoursPerDay,
-    inputUnit: options.inputUnit ?? "days"
+    hoursPerDay: options.hoursPerDay
   };
 }
 
@@ -17301,15 +18350,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,
@@ -17319,7 +18379,22 @@ function buildHistoryChangeSet(changes) {
   });
 }
 function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
-  return { changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks };
+  return {
+    changeSet,
+    beforeSnap,
+    beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
+    afterSnap,
+    afterLinks: resetDerivedLinkSnapshots(afterLinks)
+  };
+}
+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();
@@ -17373,7 +18448,7 @@ function mergeCoalesced(top, next) {
 }
 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 === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
+  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";
   }
   return "record";
@@ -17617,7 +18692,7 @@ function applyChangeSetSide(state, entry, side) {
 // 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;
   }
@@ -17626,6 +18701,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)) {
@@ -17749,40 +18832,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",
@@ -17810,7 +18909,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;
   }
@@ -17828,15 +18926,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(
@@ -17850,23 +18968,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;
       }
@@ -17886,11 +19054,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;
       }
@@ -17905,12 +19074,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);
@@ -17919,81 +19087,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();
   }
@@ -18047,14 +19281,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);
@@ -18095,6 +19329,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);
@@ -18115,9 +19367,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 ?? "",
@@ -18157,7 +19410,12 @@ function parseActivity(raw, context) {
       Number(raw.sumOfDurationRecursively ?? 0),
       context.hoursPerDay
     ),
-    isCritical: Boolean(raw.is_critical),
+    calendarDuration: computeCalendarDuration({
+      type: raw.type,
+      startDate,
+      endDate
+    }),
+    isCritical,
     freeSlackHours: null,
     expectedProgress: null,
     expectedProgressBaseline: null,
@@ -18414,6 +19672,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) {
@@ -18452,16 +19718,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) {
@@ -18521,7 +19789,8 @@ function parseSector(sector) {
     ...customIdIncrement !== void 0 ? { customIdIncrement } : {},
     ...isPrimaveraEndDate ? { updateDurationForPrimaveraEndDate: true } : {},
     activityCreter: parseActivityCreter(sector.activity_creter),
-    statusCriteria: DEFAULT_STATUS_CRITERIA
+    statusCriteria: DEFAULT_STATUS_CRITERIA,
+    ganttId: null
   };
 }
 
@@ -18587,6 +19856,9 @@ function createActivityIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createActivityIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -18618,6 +19890,9 @@ function createLinkIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createLinkIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -18653,6 +19928,9 @@ function createUniqueCorrelativeIdGenerator(options = {}) {
     }
   }
   return {
+    fork() {
+      return createUniqueCorrelativeIdGenerator({ seed: counter });
+    },
     next() {
       counter += 1;
       return String(counter);
@@ -18780,7 +20058,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;
@@ -18841,6 +20119,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);
   }
@@ -19313,6 +20604,7 @@ function recomputeSkippedLeafEnds(state) {
       durationHours: activity.durationHours,
       task: activity
     });
+    activity.calendarDuration = computeCalendarDuration(activity);
   });
 }
 function recomputeDurationsFromDates(state) {
@@ -19384,6 +20676,7 @@ function initializeCore(input) {
   );
   const sector = parsed2.sector;
   sector.statusCriteria = resolveStatusCriteria(input.statusCriteria);
+  sector.ganttId = input.ganttId ?? null;
   const calendars = parsed2.calendars;
   const baseCalendars = parsed2.baseCalendars ?? [];
   const snapshot = buildStateSnapshot(
@@ -19445,6 +20738,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,
@@ -19590,6 +21010,10 @@ function evaluateEnd(formula, proposedEdgeTimeMs) {
 }
 
 // src/init/schedule-core.ts
+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;
@@ -19613,9 +21037,11 @@ function isCurrentFilterProjection(projection, filter, context) {
   const hasCurrentLocale = projection.context.locale === context.locale;
   return hasCurrentHours && hasCurrentLocale;
 }
-var ScheduleCore = class {
+var ScheduleCore = class _ScheduleCore {
+  _activityClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
+  _isFork;
   _undo = new UndoRecorder();
   _opQueue = Promise.resolve();
   _scheduleRevision = 0;
@@ -19646,6 +21072,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,
@@ -19682,6 +21144,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;
   }
@@ -19709,6 +21180,23 @@ var ScheduleCore = class {
     this.assertReady();
     return readAllActivities(this.coreRuntime.state);
   }
+  /**
+   * Read del plan de indent (ISSUE-080): los padres destino DISTINTOS bajo los
+   * que quedarían las actividades si se indentaran ahora. Es exactamente la
+   * planificación que ejecuta el handler (`planIndentMoves`, autoridad única),
+   * expuesta para que la frontera pueda correr el protocolo de conversión a
+   * madre (chequeo backend + modal) ANTES de despachar. Solo lecturas.
+   */
+  getIndentTargetParentIds(activityIds) {
+    this.assertReady();
+    const plan = planIndentMoves(
+      activityIds.map((id) => String(id)),
+      this.coreRuntime.state
+    );
+    return [
+      ...new Set(plan.allowedMoves.map((move) => String(move.newParentId)))
+    ];
+  }
   getChildrenView(parentId) {
     this.assertReady();
     return readChildren(this.coreRuntime.state, parentId);
@@ -19717,10 +21205,45 @@ 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);
   }
+  auditEffectiveGraph() {
+    this.assertReady();
+    const state = this.coreRuntime.state;
+    const logicalLinks = state.getAllLinks();
+    const effectiveEdges = projectEffectiveEdges(state, logicalLinks);
+    const components = circularComponents(effectiveEdges);
+    let largestComponentSize = 0;
+    for (const component of components) {
+      if (component.length > largestComponentSize) {
+        largestComponentSize = component.length;
+      }
+    }
+    return {
+      activityCount: state.getAllIds().length,
+      logicalLinkCount: logicalLinks.length,
+      effectiveEdgeCount: effectiveEdges.length,
+      circularComponents: components,
+      largestComponentSize
+    };
+  }
   getProperty(activityId, property) {
     this.assertReady();
     const snapshot = this.coreRuntime.state.getActivity(activityId);
@@ -19749,11 +21272,11 @@ var ScheduleCore = class {
   }
   getActiveFilter() {
     this.assertReady();
-    return this.coreRuntime.state.getActiveFilter();
+    return cloneDomainValue(this.coreRuntime.state.getActiveFilter());
   }
   getActiveOrder() {
     this.assertReady();
-    return this.coreRuntime.state.getActiveOrder();
+    return cloneDomainValue(this.coreRuntime.state.getActiveOrder());
   }
   getVisualOrderIds() {
     this.assertReady();
@@ -19794,23 +21317,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 revision; moves once per substantive mutation. */
+  getScheduleRevision() {
+    return this._scheduleRevision;
+  }
+  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);
@@ -19905,10 +21470,18 @@ var ScheduleCore = class {
   }
   async _runDispatch(action, options) {
     this.assertReady();
+    if (this._isFork && acknowledgesPersistence(action)) {
+      return {
+        result: {
+          ok: false,
+          reason: REJECTION_REASON.SANDBOX_PERSISTENCE_FORBIDDEN
+        },
+        changedState: false
+      };
+    }
     const pipelineContext = buildPipelineContext(this.coreRuntime.state, {
       hoursPerDay: this.coreRuntime.sector.hoursPerDay,
-      dateFormat: this.coreRuntime.sector.dateFormat,
-      inputUnit: options.inputUnit ?? "days"
+      dateFormat: this.coreRuntime.sector.dateFormat
     });
     const historyPolicy = getDispatchHistoryPolicy(action);
     const generatorSnapshot = [
@@ -19928,9 +21501,12 @@ 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,
+        activityClipboard: this._activityClipboard,
         defaultBaseCalendarId: this.coreRuntime.baseCalendars.find(
           (calendar) => calendar.baseDefault
         )?.id ?? null,
@@ -19963,16 +21539,19 @@ 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)
         );
+        if (action.persistedProgress !== void 0) {
+          this._undo.clear();
+        }
       } else {
         this._saveTracker.recordChanges(
           result.changes.activities,
@@ -20236,13 +21815,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(),
@@ -20498,6 +22084,9 @@ var DEFAULT_HOURS_PER_DAY = 8;
 
 // src/dispatch/action-kinds.ts
 var DISPATCH_ACTION_KIND = {
+  ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear",
+  ACTIVITY_COPY: "activity-copy",
+  ACTIVITY_PASTE_COPIED: "activity-paste-copied",
   PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
   BASELINE_APPLY: "baseline-apply",
   PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
@@ -20515,7 +22104,6 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_INDENT: "activity-indent",
   ACTIVITY_OUTDENT: "activity-outdent",
   ACTIVITY_SET_PROGRESS: "activity-set-progress",
-  ACTIVITY_PASTE: "activity-paste",
   SELECTION_TOGGLE: "selection-toggle",
   SELECTION_REPLACE: "selection-replace",
   VISIBILITY_SET: "visibility-set",
@@ -20525,6 +22113,9 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
 };
 var KIND_CATALOG_COVERS_UNION = {
+  [DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR]: true,
+  [DISPATCH_ACTION_KIND.ACTIVITY_COPY]: true,
+  [DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED]: true,
   [DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE]: true,
   [DISPATCH_ACTION_KIND.BASELINE_APPLY]: true,
   [DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET]: true,
@@ -20542,7 +22133,6 @@ var KIND_CATALOG_COVERS_UNION = {
   [DISPATCH_ACTION_KIND.ACTIVITY_INDENT]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_PASTE]: true,
   [DISPATCH_ACTION_KIND.SELECTION_TOGGLE]: true,
   [DISPATCH_ACTION_KIND.SELECTION_REPLACE]: true,
   [DISPATCH_ACTION_KIND.VISIBILITY_SET]: true,