@outbuild-company/schedule-core 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -7,14 +7,12 @@ var Queue = class {
   enqueue(item) {
     this.items.push(item);
   }
-  /** Removes and returns the oldest item, or `undefined` when empty. */
   dequeue() {
     if (this.head >= this.items.length) return void 0;
     const item = this.items[this.head];
     this.head += 1;
     return item;
   }
-  /** The oldest item without removing it, or `undefined` when empty. */
   peek() {
     if (this.head >= this.items.length) return void 0;
     return this.items[this.head];
@@ -125,33 +123,24 @@ function isFrozen(activity) {
 
 // src/dispatch/reasons.ts
 var REJECTION_REASON = {
-  // Pipeline-gate fallbacks (used when a gate rejects without a reason).
   CANNOT_EDIT: "cannot_edit",
   PARSE_ERROR: "parse_error",
   INVALID: "invalid",
-  // Inline-edit / link validation.
   CUSTOM_ID_DUPLICATE: "custom_id_duplicate",
   INVALID_LINK_TYPE: "invalid_link_type",
   INVALID_LINK_LAG: "invalid_link_lag",
   INVALID_VALUE: "invalid_value",
-  // Bulk-edit: the column has no registered pipeline (unknown column, or a
-  // link column like custom_predecessors that dispatches as link intents).
   NO_PIPELINE_FOR_COLUMN: "no_pipeline_for_column",
-  // Entity lookups.
   ACTIVITY_NOT_FOUND: "activity_not_found",
   PARENT_NOT_FOUND: "parent_not_found",
   ACTIVITY_IDS_EMPTY: "activity_ids_empty",
-  // Anchored positioning (create / move).
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
-  // SIR freeze: cannot add a child under an activity with a pending SIR.
   PARENT_FROZEN_BY_SIR: "parent_frozen_by_sir",
-  // Hierarchy rules.
   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",
-  // Progress button.
   INVALID_PROGRESS_VALUE: "invalid_progress_value_must_be_0_or_100"
 };
 
@@ -222,14 +211,12 @@ function dispatchSelectionReplace(action, deps) {
   };
 }
 
-// src/dispatch/visibility.ts
-function dispatchVisibilitySet(action, deps) {
-  const { adapter } = deps;
-  const targetVisible = new Set(action.visibleIds.map(String));
+// src/dispatch/shared/apply-visible-set.ts
+function applyVisibleSet(adapter, visibleIds) {
   const viewState = [];
   adapter.forEachActivity((_snapshot, activityId) => {
     const id = String(activityId);
-    const willBeVisible = targetVisible.has(id);
+    const willBeVisible = visibleIds.has(id);
     const before = adapter.isVisible(id);
     if (before === willBeVisible) return;
     adapter.setVisible(id, willBeVisible);
@@ -238,6 +225,390 @@ function dispatchVisibilitySet(action, deps) {
       visible: { before, after: willBeVisible }
     });
   });
+  return viewState;
+}
+
+// src/dispatch/visibility.ts
+function dispatchVisibilitySet(action, deps) {
+  const { adapter } = deps;
+  const targetVisible = new Set(action.visibleIds.map(String));
+  const viewState = applyVisibleSet(adapter, targetVisible);
+  const changes = {
+    source: action,
+    activities: [],
+    links: [],
+    calendars: [],
+    trackingEvents: [],
+    viewState
+  };
+  return { ok: true, changes };
+}
+
+// src/internal/filter/field-registry.ts
+var STATUS_ORDER = [
+  "Waiting",
+  "Done",
+  "Doing",
+  "Overdue",
+  "Advancement"
+];
+var CONSTRAINT_TYPE_ORDER = [
+  "mfo",
+  "mso",
+  "snlt",
+  "snet",
+  "alap",
+  "asap",
+  "fnet",
+  "fnlt"
+];
+var MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
+function toDays(hours, hoursPerDay) {
+  if (hours === null) return null;
+  if (hoursPerDay <= 0) return null;
+  return hours / hoursPerDay;
+}
+function calendarDaySpan(startDate, endDate) {
+  const elapsed = endDate.getTime() - startDate.getTime();
+  return Math.floor(elapsed / MILLISECONDS_PER_DAY) + 1;
+}
+var FIELD_REGISTRY = {
+  name: { valueKind: "string", extract: (activity) => activity.name },
+  description: {
+    valueKind: "string",
+    extract: (activity) => activity.description
+  },
+  customId: { valueKind: "string", extract: (activity) => activity.customId },
+  correlativeId: {
+    valueKind: "number",
+    extract: (activity) => activity.correlativeId
+  },
+  uniqueCorrelativeId: {
+    valueKind: "number",
+    extract: (activity) => Number(activity.uniqueCorrelativeId)
+  },
+  progress: { valueKind: "number", extract: (activity) => activity.progress },
+  durationDays: {
+    valueKind: "number",
+    extract: (activity, context) => toDays(activity.durationHours, context.hoursPerDay)
+  },
+  calendarDuration: {
+    valueKind: "number",
+    extract: (activity) => calendarDaySpan(activity.startDate, activity.endDate)
+  },
+  cost: { valueKind: "number", extract: (activity) => activity.cost },
+  usedCost: { valueKind: "number", extract: (activity) => activity.usedCost },
+  realCost: { valueKind: "number", extract: (activity) => activity.realCost },
+  workHours: { valueKind: "number", extract: (activity) => activity.workHours },
+  realWorkHours: {
+    valueKind: "number",
+    extract: (activity) => activity.realWorkHours
+  },
+  ponderator: {
+    valueKind: "number",
+    extract: (activity) => activity.ponderator
+  },
+  freeSlackDays: {
+    valueKind: "number",
+    extract: (activity, context) => toDays(activity.freeSlackHours, context.hoursPerDay)
+  },
+  totalSlackDays: {
+    valueKind: "number",
+    extract: (activity, context) => toDays(
+      activity.criticalPath?.totalSlackHours ?? null,
+      context.hoursPerDay
+    )
+  },
+  expectedProgressBaseline: {
+    valueKind: "number",
+    extract: (activity) => activity.expectedProgressBaseline
+  },
+  baselineDurationDays: {
+    valueKind: "number",
+    extract: (activity) => activity.baselineSnapshot?.durationDays ?? null
+  },
+  baselineCost: {
+    valueKind: "number",
+    extract: (activity) => activity.baselineSnapshot?.cost ?? null
+  },
+  baselineWorkHours: {
+    valueKind: "number",
+    extract: (activity) => activity.baselineSnapshot?.workHours ?? null
+  },
+  startDate: { valueKind: "date", extract: (activity) => activity.startDate },
+  endDate: { valueKind: "date", extract: (activity) => activity.endDate },
+  constraintDate: {
+    valueKind: "date",
+    extract: (activity) => activity.constraintDate
+  },
+  baselineStartDate: {
+    valueKind: "date",
+    extract: (activity) => activity.baselineSnapshot?.startDate ?? null
+  },
+  baselineEndDate: {
+    valueKind: "date",
+    extract: (activity) => activity.baselineSnapshot?.endDate ?? null
+  },
+  earlyStart: {
+    valueKind: "date",
+    extract: (activity) => activity.criticalPath?.earlyStart ?? null
+  },
+  earlyFinish: {
+    valueKind: "date",
+    extract: (activity) => activity.criticalPath?.earlyFinish ?? null
+  },
+  lateStart: {
+    valueKind: "date",
+    extract: (activity) => activity.criticalPath?.lateStart ?? null
+  },
+  lateFinish: {
+    valueKind: "date",
+    extract: (activity) => activity.criticalPath?.lateFinish ?? null
+  },
+  responsableIds: {
+    valueKind: "id-array",
+    extract: (activity) => activity.responsableIds
+  },
+  tagIds: { valueKind: "id-array", extract: (activity) => activity.tagIds },
+  status: {
+    valueKind: "enum",
+    order: STATUS_ORDER,
+    extract: (activity) => activity.status
+  },
+  constraintType: {
+    valueKind: "enum",
+    order: CONSTRAINT_TYPE_ORDER,
+    extract: (activity) => activity.constraintType
+  },
+  calendarId: {
+    valueKind: "reference",
+    extract: (activity) => activity.calendarId === null ? null : String(activity.calendarId)
+  },
+  // Normalized to string like calendarId. It is stored as a number, so it used
+  // to reach compareValues through the numeric branch while its sibling
+  // reference went through the string one — the same field kind comparing two
+  // different ways. localeCompare with numeric:true keeps the digit ordering.
+  subcontractId: {
+    valueKind: "reference",
+    extract: (activity) => activity.subcontractId === null ? null : String(activity.subcontractId)
+  },
+  // Declared boolean, not enum: it is one, and saying so is what lets the enum
+  // branch demand an order without inventing one for true/false.
+  isCritical: {
+    valueKind: "boolean",
+    extract: (activity) => activity.isCritical
+  }
+};
+function getFieldDescriptor(field) {
+  return FIELD_REGISTRY[field] ?? null;
+}
+
+// src/internal/filter/evaluate-filter.ts
+function toTargetDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") {
+    return new Date(value);
+  }
+  return new Date(Number.NaN);
+}
+function matchString(value, target, operator) {
+  const isAbsent = value === null;
+  if (operator === "includes") {
+    return !isAbsent && String(value).toLowerCase().includes(target.toLowerCase());
+  }
+  if (operator === "notIncludes") {
+    return isAbsent || !String(value).toLowerCase().includes(target.toLowerCase());
+  }
+  if (operator === "is") return !isAbsent && String(value) === target;
+  if (operator === "isNot") return isAbsent || String(value) !== target;
+  return false;
+}
+function matchNumber(value, target, operator) {
+  if (value === null || typeof value !== "number") {
+    return operator === "notEquals";
+  }
+  if (operator === "equals") return value === target;
+  if (operator === "notEquals") return value !== target;
+  if (operator === "greaterThan") return value > target;
+  if (operator === "lessThan") return value < target;
+  if (operator === "greaterOrEqual") return value >= target;
+  if (operator === "lessOrEqual") return value <= target;
+  return false;
+}
+function matchDate(value, target, operator) {
+  if (!(value instanceof Date)) return false;
+  if (operator === "after") return value.getTime() > target.getTime();
+  if (operator === "before") return value.getTime() < target.getTime();
+  return false;
+}
+function matchIdArray(value, allowed, operator) {
+  const ids = Array.isArray(value) ? value : [];
+  const intersects = ids.some((id) => allowed.has(String(id)));
+  if (operator === "someOf") return intersects;
+  if (operator === "notSomeOf") return !intersects;
+  return false;
+}
+function matchEnum(value, allowed, operator) {
+  const isMember = value !== null && allowed.has(String(value));
+  if (operator === "someOf") return isMember;
+  if (operator === "notSomeOf") return !isMember;
+  return false;
+}
+function toAllowedSet(value) {
+  const items = Array.isArray(value) ? value : [value];
+  return new Set(items.map((item) => String(item)));
+}
+function matchCriterion(activity, criterion, context) {
+  const descriptor = getFieldDescriptor(criterion.field);
+  if (descriptor === null) return false;
+  const value = descriptor.extract(activity, context);
+  const { operator } = criterion;
+  if (descriptor.valueKind === "string") {
+    return matchString(value, String(criterion.value), operator);
+  }
+  if (descriptor.valueKind === "number") {
+    return matchNumber(value, Number(criterion.value), operator);
+  }
+  if (descriptor.valueKind === "date") {
+    return matchDate(value, toTargetDate(criterion.value), operator);
+  }
+  if (descriptor.valueKind === "id-array") {
+    return matchIdArray(value, toAllowedSet(criterion.value), operator);
+  }
+  return matchEnum(value, toAllowedSet(criterion.value), operator);
+}
+function matchesCriteria(activity, filter, context) {
+  if (filter.criteria.length === 0) return true;
+  if (filter.logic === "or") {
+    return filter.criteria.some(
+      (criterion) => matchCriterion(activity, criterion, context)
+    );
+  }
+  return filter.criteria.every(
+    (criterion) => matchCriterion(activity, criterion, context)
+  );
+}
+function overlapsRange(activity, range) {
+  const taskStart = activity.startDate.getTime();
+  const taskEnd = activity.endDate.getTime();
+  const windowStart = range.start.getTime();
+  const windowEnd = range.end.getTime();
+  const fullyInside = taskStart >= windowStart && taskEnd <= windowEnd;
+  const startsInside = taskStart >= windowStart && taskStart <= windowEnd;
+  const windowStartsInside = windowStart >= taskStart && windowStart <= taskEnd;
+  return fullyInside || startsInside || windowStartsInside;
+}
+function addAncestors(matchedId, parentOf, visibleIds) {
+  let ancestorId = parentOf(matchedId);
+  while (ancestorId !== null && !visibleIds.has(String(ancestorId))) {
+    visibleIds.add(String(ancestorId));
+    ancestorId = parentOf(ancestorId);
+  }
+}
+function evaluateVisibleIds(input) {
+  const { activities, parentOf, filter, context } = input;
+  const range = filter.dateRange;
+  const visibleIds = /* @__PURE__ */ new Set();
+  const matchedIds = [];
+  for (const activity of activities) {
+    const passesCriteria = matchesCriteria(activity, filter, context);
+    const passesRange = range === void 0 || overlapsRange(activity, range);
+    if (passesCriteria && passesRange) {
+      visibleIds.add(String(activity.id));
+      matchedIds.push(activity.id);
+    }
+  }
+  for (const matchedId of matchedIds) {
+    addAncestors(matchedId, parentOf, visibleIds);
+  }
+  return visibleIds;
+}
+
+// src/internal/filter/context.ts
+var COLLATION_LOCALE = "en";
+function buildFilterContext(hoursPerDay) {
+  return { hoursPerDay, locale: COLLATION_LOCALE };
+}
+
+// src/internal/filter/validate.ts
+var OPERATORS_BY_KIND = {
+  string: /* @__PURE__ */ new Set(["includes", "notIncludes", "is", "isNot"]),
+  number: /* @__PURE__ */ new Set([
+    "equals",
+    "notEquals",
+    "greaterThan",
+    "lessThan",
+    "greaterOrEqual",
+    "lessOrEqual"
+  ]),
+  date: /* @__PURE__ */ new Set(["after", "before"]),
+  "id-array": /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
+  enum: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
+  // Same membership operators as enum: splitting the kinds was about ordering,
+  // not about filtering, and these two filter exactly like an enum.
+  boolean: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
+  reference: /* @__PURE__ */ new Set(["someOf", "notSomeOf"])
+};
+function validateCriterion(criterion) {
+  const descriptor = getFieldDescriptor(criterion.field);
+  if (descriptor === null) return "unknown_field";
+  if (!OPERATORS_BY_KIND[descriptor.valueKind].has(criterion.operator)) {
+    return "unknown_operator";
+  }
+  return validateValueForKind(criterion, descriptor.valueKind);
+}
+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 === "date") {
+    return isValidDateValue(value) ? null : "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;
+}
+
+// src/dispatch/filter.ts
+function isEmptyFilter(filter) {
+  return filter.criteria.length === 0 && filter.dateRange === void 0;
+}
+function resolveVisibleIds(adapter, filter, hoursPerDay) {
+  const activities = adapter.getAllActivities();
+  if (isEmptyFilter(filter)) {
+    return new Set(activities.map((activity) => String(activity.id)));
+  }
+  return evaluateVisibleIds({
+    activities,
+    parentOf: (activityId) => adapter.getParentId(activityId),
+    filter,
+    context: buildFilterContext(hoursPerDay)
+  });
+}
+function dispatchFilterSet(action, deps) {
+  const { adapter, hoursPerDay } = deps;
+  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
+  };
+  adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
+  const visibleIds = resolveVisibleIds(adapter, filter, hoursPerDay);
+  const viewState = applyVisibleSet(adapter, visibleIds);
   const changes = {
     source: action,
     activities: [],
@@ -249,6 +620,140 @@ function dispatchVisibilitySet(action, deps) {
   return { ok: true, changes };
 }
 
+// src/internal/hierarchy/root-parent.ts
+var ROOT_PARENT_ID = "0";
+function isRootParent(parent) {
+  return parent == null || parent === 0 || parent === ROOT_PARENT_ID;
+}
+function normalizeParentKey(parent) {
+  return isRootParent(parent) ? ROOT_PARENT_ID : String(parent);
+}
+
+// src/internal/hierarchy/visual-order.ts
+var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
+function getChildrenInVisualOrder(parentId, adapter) {
+  const children = collectChildrenSnapshots(parentId, adapter);
+  const userOrder = adapter.getOrderComparator?.() ?? null;
+  children.sort(
+    userOrder === null ? compareActivitiesInVisualOrder : (a, b) => userOrder(a, b) || compareActivitiesInVisualOrder(a, b)
+  );
+  return children.map((a) => String(a.id));
+}
+function iterateInVisualOrder(adapter) {
+  const result = [];
+  const visit = (activity) => {
+    result.push(activity);
+    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
+    for (const childId of childIds) {
+      const child = adapter.getActivity(childId);
+      if (child) visit(child);
+    }
+  };
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  for (const rootId of rootIds) {
+    const root = adapter.getActivity(rootId);
+    if (root) visit(root);
+  }
+  return result;
+}
+function findPreviousNonSelectedSibling(taskId, selected, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return null;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  const idx = siblings.findIndex((id) => String(id) === String(taskId));
+  if (idx <= 0) return null;
+  for (let i = idx - 1; i >= 0; i--) {
+    const candidateId = siblings[i];
+    if (candidateId === void 0) continue;
+    if (!setHas(selected, candidateId)) return candidateId;
+  }
+  return null;
+}
+function visualIndexInParent(taskId, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return -1;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  return siblings.findIndex((id) => String(id) === String(taskId));
+}
+function collectChildrenSnapshots(parentId, adapter) {
+  const key = String(parentId);
+  if (key === "0") {
+    return adapter.getAllActivities().filter((a) => a.parentId === null);
+  }
+  const childIds = adapter.getChildren(parentId);
+  const out = [];
+  for (const id of childIds) {
+    const snap = adapter.getActivity(id);
+    if (snap) out.push(snap);
+  }
+  return out;
+}
+function compareActivitiesInVisualOrder(a, b) {
+  const ac = correlativeIdOf(a);
+  const bc = correlativeIdOf(b);
+  if (ac !== bc) return ac - bc;
+  return String(a.id).localeCompare(String(b.id));
+}
+function correlativeIdOf(activity) {
+  const raw = activity.correlativeId;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
+}
+function parentKeyOf(activity) {
+  const parentId = activity.parentId;
+  if (parentId === null) return "0";
+  return parentId;
+}
+function setHas(set, id) {
+  if (set.has(id)) return true;
+  return set.has(String(id));
+}
+
+// src/dispatch/shared/collect-branch-order.ts
+function collectBranchOrder(adapter) {
+  const branches = [];
+  const visit = (parentId) => {
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    if (childIds.length > 1) {
+      branches.push({ parentId, childIds });
+    }
+    for (const childId of childIds) {
+      visit(childId);
+    }
+  };
+  visit(ROOT_PARENT_ID);
+  return branches;
+}
+
+// src/dispatch/order.ts
+function validateRule(rule) {
+  if (getFieldDescriptor(rule.field) === null) return "unknown_field";
+  if (rule.direction !== "asc" && rule.direction !== "desc") {
+    return "unknown_operator";
+  }
+  return null;
+}
+function dispatchSortSet(action, deps) {
+  const { adapter } = deps;
+  for (const rule of action.rules) {
+    const rejection = validateRule(rule);
+    if (rejection !== null) return { ok: false, reason: rejection };
+  }
+  const order = action.rules.length === 0 ? null : { rules: action.rules };
+  adapter.setActiveOrder(order);
+  const changes = {
+    source: action,
+    activities: [],
+    links: [],
+    calendars: [],
+    trackingEvents: [],
+    order: collectBranchOrder(adapter)
+  };
+  return { ok: true, changes };
+}
+
 // src/columns/text/constants.ts
 var TEXT = "text";
 
@@ -630,19 +1135,22 @@ var ACTIVITY_TYPE = {
   MILESTONE: "milestone"
 };
 var TIMING = {
-  // 16ms = full frame budget; 8ms = yield twice per frame so the
-  // browser still has half a frame to paint and handle input.
   YIELD_SLICE_MS: 8
 };
 
 // src/shared/timing.ts
 var isNode = typeof window === "undefined";
-var channel = !isNode && typeof MessageChannel !== "undefined" ? new MessageChannel() : null;
+var hasMessageChannel = !isNode && typeof MessageChannel !== "undefined";
 function yieldToBrowser() {
-  if (isNode || !channel) return Promise.resolve();
+  if (!hasMessageChannel) return Promise.resolve();
   return new Promise((resolve) => {
-    channel.port1.onmessage = () => resolve();
-    channel.port2.postMessage(null);
+    const oneShotChannel = new MessageChannel();
+    oneShotChannel.port1.onmessage = () => {
+      oneShotChannel.port1.close();
+      oneShotChannel.port2.close();
+      resolve();
+    };
+    oneShotChannel.port2.postMessage(null);
   });
 }
 
@@ -1250,7 +1758,6 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter)
       startDate: date2,
       durationHours: sourceLag,
       task: predecessor
-      // sourceLag always on predecessor calendar
     });
   }
   if (targetLag !== 0) {
@@ -1258,7 +1765,6 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter)
       startDate: date2,
       durationHours: targetLag,
       task: successor
-      // targetLag always on successor calendar
     });
   }
   if (trueLag !== 0) {
@@ -1266,7 +1772,6 @@ function calculateSuccessorStartFromLink(predecessor, successor, link, adapter)
       startDate: date2,
       durationHours: trueLag,
       task: successor
-      // trueLag always on successor calendar
     });
   }
   if (successor.durationHours === 0) {
@@ -1555,15 +2060,6 @@ function isSummaryActivity(activity, adapter) {
   return isSummary(activity.type, adapter.getChildren(activity.id).length > 0);
 }
 
-// src/internal/hierarchy/root-parent.ts
-var ROOT_PARENT_ID = "0";
-function isRootParent(parent) {
-  return parent == null || parent === 0 || parent === ROOT_PARENT_ID;
-}
-function normalizeParentKey(parent) {
-  return isRootParent(parent) ? ROOT_PARENT_ID : String(parent);
-}
-
 // src/autoscheduler/engine/alap-pass.ts
 async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurrent) {
   const plans = new Map(asapPlans);
@@ -1916,8 +2412,6 @@ function parseEntry(entry) {
     lag = sign === "-" ? -value : value;
   }
   return {
-    // frozen logic: invariant guaranteed by ENTRY_RE — capture group 1 `(\d+)`
-    // is non-optional, so a successful match always defines correlativeId
     correlativeId,
     type,
     lag
@@ -2024,36 +2518,6 @@ function lagDaysToHours(lagDays, hoursPerDay) {
 
 // src/autoscheduler/date-math/impl-current.ts
 var currentImpl = {
-  /**
-   * Legacy rule observed empirically from 4 fixtures:
-   *
-   *   midnight = setHours(0, 0, 0, 0) on a copy of rawDate (local TZ)
-   *   if (midnight.getTime() === rawDate.getTime())
-   *     return calendar.getClosestWorkTime(raw, 'future')   // snap forward
-   *   else
-   *     return midnight                                      // preserve day
-   *
-   * Rationale (inferred): when the user types/picks a date AT local
-   * midnight (e.g., Saturday 00:00 local = "just Saturday"), legacy
-   * interprets it as "start of the week/day" and snaps to the next
-   * working hour.  When they pick a time WITHIN a day (e.g., Sunday
-   * 08:00 local), legacy treats it as "this specific day" and preserves
-   * the day at local midnight, even if the day is non-working.
-   *
-   * Fixture evidence:
-   *   - test3: raw=Apr 26 06:00Z (Sun 08:00 CEST) → Apr 25 22:00Z (Sun 00:00 CEST)
-   *   - create-rename-drag: raw=Apr 23 22:00Z (Fri 00:00 CEST) → Apr 24 06:00Z (snap)
-   *   - create-rename-drag: raw=Apr 25 22:00Z (Sun 00:00 CEST) → Apr 27 06:00Z (snap)
-   *
-   * UTC contract: `setUTCHours(0)` makes the normalization deterministic
-   * regardless of the runtime's local TZ.  The work-calendar package (and
-   * any future strict-UTC calendar engine) requires UTC-keyed inputs, so
-   * the day boundary must be computed in UTC too.  Legacy fixtures
-   * recorded under local-TZ midnight may need their `metadata.tz` honored
-   * upstream — `pipeline-context.ts` plumbs that field but this function
-   * does not yet consume it (its caller supplies a raw Date with the
-   * recorded instant intact).
-   */
   rawInputToConstraintDate(rawDate, calendar) {
     const midnight = new Date(rawDate);
     midnight.setUTCHours(0, 0, 0, 0);
@@ -2069,16 +2533,6 @@ var currentImpl = {
     }
     return midnight;
   },
-  /**
-   * Legacy behavior replicated (from `modifyLagCustom.js:29-35`):
-   *   `calendar.calculateDuration(sourceDate, targetDate)`
-   *
-   * Returns working hours between the two dates according to the task's
-   * calendar (working days + working hours range).  Positive when
-   * targetDate > sourceDate, zero when aligned.  Negative branch
-   * exists in calendar.calculateDuration (reverse walk) but our
-   * current usage always has target after source post-move.
-   */
   computeLagBetweenTasks(sourceDate, targetDate, calendar) {
     return calendar.calculateDuration(sourceDate, targetDate);
   }
@@ -2115,36 +2569,16 @@ var AutoScheduler = class {
   getCurrentCalculationId() {
     return this.currentCalculationId;
   }
-  /**
-   * Invalidates the cached full-graph topological order. Call after any
-   * structural mutation: link create/delete, activity create/delete,
-   * activity reparent (indent/outdent/move).
-   */
   invalidateTopoCache() {
     this.topoCache.invalidate();
   }
-  /**
-   * Invalidates the cached expanded parent-link set. Call on link create /
-   * delete, activity reparent, activity create / delete, and on the rare
-   * field edits that affect chain-pruning (`duration`, `auto_scheduling`).
-   */
   invalidateExpandedLinksCache() {
     this.expandedLinksCache.invalidate();
   }
-  /**
-   * Convenience: invalidate every cache held by the scheduler.
-   */
   invalidateAllCaches() {
     this.topoCache.invalidate();
     this.expandedLinksCache.invalidate();
   }
-  /**
-   * Main entry point.  Runs the full scheduling algorithm.
-   *
-   * Returns a ScheduleResult with the plans, updated IDs, and status.
-   * The caller (integration layer) is responsible for applying the results
-   * back to gantt.
-   */
   async schedule(options = {}) {
     const calculationId = ++this.currentCalculationId;
     const isCurrent = createIsCurrent(
@@ -2513,16 +2947,6 @@ function sortDeepestFirst(ids, depths) {
 // src/internal/post-processors/runner.ts
 var POST_PROCESSORS = {
   updateActivityDuration: runUpdateActivityDuration,
-  // `updateMilestoneData` eliminado del registro (2026-06-10, MIL-B2):
-  // post-processor fantasma — ninguna pipeline lo emitía. Su garantía
-  // (duration=0, end_date=start_date al convertir a milestone) vive en
-  // durationPipeline (fix MIL-B1) + calculateEndDate(start, 0) === start
-  // (test en calendar/adapter.test.ts). Ver BUGS_milestones_2026-06-10.md
-  // (vault).
-  // `executeFixForConstraints` (legacy) se reimplementa fuera de este registro
-  // como `revertNoOpConstraintEdit` (post-pass del dispatch de constraint, tras
-  // la cascada) — NO como post-processor por-pipeline. `recordLastStartDate`
-  // guarda el baseline del gesto (start al editar duración) que ese revert lee.
   updateTaskTiming: runNoOp("updateTaskTiming"),
   adjustLinkLagOnTaskMove,
   recordLastStartDate: runRecordLastStartDate
@@ -2945,7 +3369,6 @@ function buildDescendantCascade(activity, newValue, autoScheduling, hierarchy, r
   const descendants = hierarchy.getDescendantIds(activity.id);
   return descendants.map((id) => ({
     activityId: id,
-    // Descendants of a recursive progress change inherit the primary value.
     fields: descendantFields(
       newValue,
       autoScheduling,
@@ -3258,7 +3681,6 @@ var startDatePipeline = {
         {
           startDate: finalStart,
           ...setEndDate(finalEnd),
-          // Sanea la duration de un milestone corrupto en el mismo move.
           ...milestoneActivity ? setDuration(0) : {},
           ...setConstraintTypeImplied(),
           ...setConstraintDate(constraintDate)
@@ -3537,9 +3959,11 @@ var calendarIdPipeline = {
     if (isEmpty(value)) return parseError("empty_calendar");
     return parsed(value);
   },
-  validate(activity, _oldValue, newValue) {
+  validate(activity, _oldValue, newValue, ctx) {
     if (isUnchangedCalendar(activity.calendarId, newValue))
       return invalid("unchanged");
+    if (!ctx.calendars.getCalendar(newValue))
+      return invalid("unknown_calendar");
     return valid();
   },
   transform(activity, newValue, ctx) {
@@ -3754,9 +4178,6 @@ var COLUMN_PIPELINES = /* @__PURE__ */ new Map([
   [COLUMN.CONSTRAINT_DATE, constraintDatePipeline],
   [COLUMN.CALENDAR_ID, calendarIdPipeline],
   [COLUMN.CUSTOM_ID, customIdPipeline],
-  // Naming exception: `subcontractId` stays camelCase for parity with
-  // production (backend BD + legacy column + `BackendActivityInput.subcontractId`).
-  // Snake-case unification deferred to a global pass.
   [COLUMN.SUBCONTRACT_ID, subcontractIdPipeline],
   [COLUMN.RESPONSABLES, responsablesPipeline],
   [COLUMN.TAGS, tagsPipeline]
@@ -3881,7 +4302,13 @@ 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) {
   const ids = /* @__PURE__ */ new Set([String(primary)]);
   for (const mutation of changes.cascadeMutations ?? []) {
@@ -3889,9 +4316,12 @@ function collectTouchedIds(primary, changes) {
   }
   return ids;
 }
-function snapshotActivities(adapter, ids) {
+async function snapshotActivities(adapter, ids) {
   const out = /* @__PURE__ */ new Map();
+  let processed = 0;
   for (const id of ids) {
+    processed += 1;
+    if (processed % YIELD_EVERY_N_ENTRIES === 0) await yieldToBrowser();
     const a = adapter.getActivity(id);
     if (a) out.set(id, structuredCloneActivity(a));
   }
@@ -3900,6 +4330,10 @@ function snapshotActivities(adapter, ids) {
 function structuredCloneActivity(activity) {
   return cloneCoreActivity(activity);
 }
+function snapshotSingleActivity(adapter, activityId) {
+  const liveActivity = adapter.getActivity(activityId);
+  return liveActivity ? cloneCoreActivity(liveActivity) : null;
+}
 function applyFieldChanges(adapter, activityId, changes) {
   applyCanonicalPatch(adapter, activityId, changes.patch);
   for (const mutation of changes.cascadeMutations ?? []) {
@@ -3916,35 +4350,69 @@ function applyCanonicalPatch(adapter, activityId, patch) {
     setActivityFieldDynamic(adapter, activityId, key, value);
   }
 }
-function buildActivityChanges(adapter, before, touched) {
+async function buildActivityChanges(adapter, before, touched, correlativeBefore) {
   const out = [];
+  let processed = 0;
   for (const id of touched) {
-    const afterSnap = adapter.getActivity(id);
-    if (!afterSnap) {
-      out.push({ id, kind: "deleted", after: null });
-      continue;
-    }
-    const beforeSnap = before.get(id);
-    const diff = diffActivity(beforeSnap, afterSnap);
-    if (beforeSnap && Object.keys(diff).length === 0) continue;
-    if (!beforeSnap) {
-      out.push({
-        id,
-        kind: "created",
-        fields: diff,
-        after: structuredCloneActivity(afterSnap)
-      });
-    } else {
-      out.push({
-        id,
-        kind: "updated",
-        fields: diff,
-        after: structuredCloneActivity(afterSnap)
-      });
-    }
+    processed += 1;
+    if (processed % YIELD_EVERY_N_ENTRIES === 0) await yieldToBrowser();
+    const entry = buildEntryForTouchedId(
+      adapter,
+      before,
+      id,
+      correlativeBefore
+    );
+    if (entry) out.push(entry);
   }
   return out;
 }
+function buildEntryForTouchedId(adapter, before, activityId, correlativeBefore) {
+  const afterSnap = adapter.getActivity(activityId);
+  if (!afterSnap) {
+    return { id: activityId, kind: "deleted", after: null };
+  }
+  const beforeSnap = before.get(activityId);
+  if (!beforeSnap && correlativeBefore?.has(activityId)) {
+    return buildCorrelativeOnlyEntry(
+      activityId,
+      correlativeBefore.get(activityId),
+      afterSnap
+    );
+  }
+  const diff = diffActivity(beforeSnap, afterSnap);
+  mergeCorrelativeShiftIntoDiff(diff, correlativeBefore, activityId, afterSnap);
+  if (beforeSnap && Object.keys(diff).length === 0) return null;
+  return {
+    id: activityId,
+    kind: beforeSnap ? "updated" : "created",
+    fields: diff,
+    after: structuredCloneActivity(afterSnap)
+  };
+}
+function buildCorrelativeOnlyEntry(activityId, correlativeIdBefore, liveActivity) {
+  if (correlativeIdBefore === liveActivity.correlativeId) return null;
+  return {
+    id: activityId,
+    kind: "updated",
+    fields: {
+      correlativeId: {
+        before: correlativeIdBefore,
+        after: liveActivity.correlativeId
+      }
+    },
+    after: structuredCloneActivity(liveActivity)
+  };
+}
+function mergeCorrelativeShiftIntoDiff(diff, correlativeBefore, activityId, liveActivity) {
+  if (!correlativeBefore?.has(activityId)) return;
+  if (Object.hasOwn(diff, "correlativeId")) return;
+  const shiftedFrom = correlativeBefore.get(activityId);
+  if (shiftedFrom === liveActivity.correlativeId) return;
+  diff.correlativeId = {
+    before: shiftedFrom,
+    after: liveActivity.correlativeId
+  };
+}
 function diffActivity(before, after) {
   const fields = {};
   const beforeRec = before ?? {};
@@ -3952,11 +4420,19 @@ function diffActivity(before, after) {
   const keys = /* @__PURE__ */ new Set([...Object.keys(beforeRec), ...Object.keys(afterRec)]);
   for (const k of keys) {
     if (Object.hasOwn(beforeRec, k) !== Object.hasOwn(afterRec, k) || !fieldValueEqual(beforeRec[k], afterRec[k])) {
-      fields[k] = { before: beforeRec[k], after: afterRec[k] };
+      fields[k] = {
+        before: cloneFieldValue(beforeRec[k]),
+        after: cloneFieldValue(afterRec[k])
+      };
     }
   }
   return fields;
 }
+function cloneFieldValue(value) {
+  const isPrimitive = value === null || typeof value !== "object";
+  if (isPrimitive) return value;
+  return cloneDomainValue(value);
+}
 function fieldValueEqual(left, right) {
   if (Object.is(left, right)) return true;
   if (left instanceof Date && right instanceof Date) {
@@ -4633,12 +5109,6 @@ function mutateTheDateToFutureOrPastInBaseRestriction(dateBaseToCalculate, restr
 
 // src/critical-path/legacy/base/parents-calculations/forward.js
 var CalculateForwardParentsWithLinks = class {
-  /**
-   * Initializes the calculator with linked activities, the current activity, and the gantt instance.
-   * @param {Array<Object>} linkedActivitiesData - Array of linked activities data.
-   * @param {Object} activity - The current activity object.
-   * @param {Object} gantt - The gantt instance.
-   */
   constructor(linkedActivitiesData, activity, gantt) {
     this.linkedActivitiesData = linkedActivitiesData;
     this.activity = activity;
@@ -4650,10 +5120,6 @@ var CalculateForwardParentsWithLinks = class {
       );
     }
   }
-  /**
-   * Main method to perform the calculation.
-   * @returns {Object} The calculation result.
-   */
   calculate() {
     const calculationsFromLinks = this.calculateLinks();
     const maxEfFromLinks = getMaxEarlyStartSet(calculationsFromLinks);
@@ -4666,10 +5132,6 @@ var CalculateForwardParentsWithLinks = class {
     }
     return maxEfFromLinks;
   }
-  /**
-   * Calculates the dates based on the linked activities.
-   * @returns {Array<Object>} Array of calculation results from links.
-   */
   calculateLinks() {
     const calculations = [];
     for (const linkedActivity of this.linkedActivitiesData) {
@@ -4700,11 +5162,6 @@ var CalculateForwardParentsWithLinks = class {
     }
     return calculations;
   }
-  /**
-   * Handles the 'Start No Earlier Than' (SNET) constraint.
-   * @param {Object|null} maxEfFromLinks - The maximum early finish from links.
-   * @returns {Object} The calculation result considering the constraint.
-   */
   handleSNETConstraint(maxEfFromLinks) {
     const restriction = calculateRestrictionSnet({
       duration: this.activity.duration,
@@ -4717,11 +5174,6 @@ var CalculateForwardParentsWithLinks = class {
     }
     return maxEfFromLinks.ef > restriction.ef ? maxEfFromLinks : restriction;
   }
-  /**
-   * Handles the 'Finish No Later Than' (FNLT) constraint.
-   * @param {Object|null} maxEfFromLinks - The maximum early finish from links.
-   * @returns {Object} The calculation result considering the constraint.
-   */
   handleFNLTConstraint(maxEfFromLinks) {
     const restriction = calculateRestriction({
       duration: -this.activity.duration,
@@ -4734,11 +5186,6 @@ var CalculateForwardParentsWithLinks = class {
     }
     return maxEfFromLinks.ef > restriction.ef ? restriction : maxEfFromLinks;
   }
-  /**
-   * Calculates dates for 'Start to Start' (SS) link type.
-   * @param {Object} params - Parameters containing lag and predecessor early start.
-   * @returns {Object} The calculation result.
-   */
   calculateSSLink({ lag, predecessorEs }) {
     const esLinked = mutateDate({
       linkType: "ss",
@@ -4769,11 +5216,6 @@ var CalculateForwardParentsWithLinks = class {
     );
     return { es, ef };
   }
-  /**
-   * Calculates dates for 'Finish to Finish' (FF) link type.
-   * @param {Object} params - Parameters containing lag and predecessor early finish.
-   * @returns {Object} The calculation result.
-   */
   calculateFFLink({ lag, predecessorEf }) {
     const efLinked = mutateDate({
       linkType: "ff",
@@ -4804,11 +5246,6 @@ var CalculateForwardParentsWithLinks = class {
     }
     return { es, ef };
   }
-  /**
-   * Calculates dates for 'Finish to Start' (FS) link type.
-   * @param {Object} params - Parameters containing lag and predecessor early finish.
-   * @returns {Object} The calculation result.
-   */
   calculateFSLink({ lag, predecessorEf }) {
     let efLinked = predecessorEf;
     if (lag === 0) {
@@ -4833,11 +5270,6 @@ var CalculateForwardParentsWithLinks = class {
     );
     return { es, ef };
   }
-  /**
-   * Calculates dates for 'Start to Finish' (SF) link type.
-   * @param {Object} params - Parameters containing lag, predecessor early start, and finish.
-   * @returns {Object} The calculation result.
-   */
   calculateSFLink({ lag, predecessorEs }) {
     const ef = addDurationToDate(
       this.activityCalendar,
@@ -5143,14 +5575,6 @@ var CalculateBackwardParentsLinks = class {
     });
     return newDate;
   }
-  /**
-   * Determines if a given date corresponds to the initial work hour of an activity as defined in the activity calendar.
-   * This function retrieves the first work interval from the activity calendar and compares the hour portion
-   * of the input date to the start hour of the work interval.
-   * @param {object} activityCalendar - The calendar object containing work hours and scheduling information for the activity.
-   * @param {Date} date - The date to check against the activity's start hour.
-   * @returns {boolean} True if the hour of the input date matches the initial work hour of the activity; otherwise, false.
-   */
   isActivityInInitHour(activityCalendar, date2) {
     const normalizedDate = date2 instanceof Date ? date2 : new Date(date2);
     const shifts = activityCalendar.getWorkHours(normalizedDate);
@@ -5491,22 +5915,12 @@ var calculation_of_parent_default = CalculationOfParent;
 
 // src/critical-path/legacy/base/third-level-activities/index.js
 var ThirdLevelActivityIdentifier = class {
-  /**
-   * Constructs the ThirdLevelActivityIdentifier class.
-   * @param {Object} params - The parameters object.
-   * @param {Object} params.gantt - The Gantt chart instance.
-   * @param {Object} params.filters - Filters for tasks.
-   * @param {string} params.linkProperty - The property name for links.
-   */
   constructor({ gantt, linkProperty }) {
     this.gantt = gantt;
     this.linkProperty = linkProperty;
     this.structureOfParents = /* @__PURE__ */ new Map();
     this.singleParents = /* @__PURE__ */ new Map();
   }
-  /**
-   * Identifies third-level activities and populates the structureOfParents map.
-   */
   identifyThirdLevelActivities() {
     try {
       const parents = this.getFirstLevelParents();
@@ -5531,18 +5945,9 @@ var ThirdLevelActivityIdentifier = class {
       throw e;
     }
   }
-  /**
-   * Retrieves the first-level parent tasks.
-   * @returns {Array<Object>} Array of parent tasks.
-   */
   getFirstLevelParents() {
     return this.gantt.getTaskByTime().filter(filters_default.byFirstLevel).filter(filters_default.filterByParentType);
   }
-  /**
-   * Processes each activity under a parent task.
-   * @param {Object} parentActivity - The parent activity to process.
-   * @returns {Object} Processed data including parentsIds, allTasks, activitiesByLevel.
-   */
   processEachActivity(parentActivity) {
     const parentsIds = /* @__PURE__ */ new Set();
     const allTasks = /* @__PURE__ */ new Set();
@@ -5557,10 +5962,6 @@ var ThirdLevelActivityIdentifier = class {
       activitiesByLevel
     };
   }
-  /**
-   * Initializes the parent activity in singleParents map.
-   * @param {Object} parentActivity - The parent activity.
-   */
   initializeParent(parentActivity) {
     const parentId = Number(parentActivity.id);
     const hasLink = Boolean(parentActivity[this.linkProperty]?.length);
@@ -5571,13 +5972,6 @@ var ThirdLevelActivityIdentifier = class {
       childrens: []
     });
   }
-  /**
-   * Processes a single activity.
-   * @param {Object} activity - The activity to process.
-   * @param {Set<number>} parentsIds - Set of parent IDs.
-   * @param {Set<number>} allTasks - Set of all task IDs.
-   * @param {Map<number, Map<number, Array<Object>>>} activitiesByLevel - Activities grouped by level.
-   */
   processActivity(activity, parentsIds, allTasks, activitiesByLevel) {
     const activityId = Number(activity.id);
     const parentId = Number(activity.parent);
@@ -5592,27 +5986,12 @@ var ThirdLevelActivityIdentifier = class {
     }
     this.addActivityToLevel(activity, activitiesByLevel);
   }
-  /**
-   * Checks if an activity is a project (parent activity).
-   * @param {Object} activity - The activity to check.
-   * @returns {boolean} True if the activity is a project.
-   */
   isProjectActivity(activity) {
     return activity.type === "project";
   }
-  /**
-   * Checks if an activity has a link.
-   * @param {Object} activity - The activity to check.
-   * @returns {boolean} True if the activity has a link.
-   */
   hasLink(activity) {
     return Boolean(activity[this.linkProperty]?.length);
   }
-  /**
-   * Adds parent information to singleParents map.
-   * @param {Object} activity - The parent activity.
-   * @param {Set<number>} parentsIds - Set of parent IDs.
-   */
   addParentInfo(activity, parentsIds) {
     const parentId = Number(activity.id);
     const level = activity["$level"];
@@ -5625,27 +6004,12 @@ var ThirdLevelActivityIdentifier = class {
     parentsIds.add(parentId);
     this.singleParents.set(parentId, parentInfo);
   }
-  /**
-   * Checks if a parent exists in singleParents map.
-   * @param {number} parentId - The parent ID to check.
-   * @returns {boolean} True if the parent exists.
-   */
   doesParentExist(parentId) {
     return this.singleParents.has(parentId);
   }
-  /**
-   * Adds a child activity to its parent in singleParents map.
-   * @param {number} parentId - The parent ID.
-   * @param {number} activityId - The child activity ID.
-   */
   addChildToParent(parentId, activityId) {
     this.singleParents.get(parentId).childrens.push(activityId);
   }
-  /**
-   * Adds an activity to the activitiesByLevel map.
-   * @param {Object} activity - The activity to add.
-   * @param {Map<number, Map<number, Array<Object>>>} activitiesByLevel - Activities grouped by level.
-   */
   addActivityToLevel(activity, activitiesByLevel) {
     const levelKey = activity["$level"];
     const parentKey = Number(activity.parent);
@@ -5662,33 +6026,15 @@ var ThirdLevelActivityIdentifier = class {
       calculated: false
     });
   }
-  /**
-   * Retrieves all levels from activitiesByLevel map.
-   * @param {Map<number, Map<number, Array<Object>>>} activitiesByLevel - Activities grouped by level.
-   * @returns {Set<number>} Set of all levels.
-   */
   getAllLevels(activitiesByLevel) {
     return new Set(activitiesByLevel.keys());
   }
-  /**
-   * Determines the deepest level from a set of levels.
-   * @param {Set<number>} allLevels - Set of all levels.
-   * @returns {number} The deepest level.
-   */
   getDeepestLevel(allLevels) {
     if (allLevels.size === 0) {
       return 0;
     }
     return Math.max(...allLevels);
   }
-  /**
-   * Creates the result object for a parent activity.
-   * @param {Object} parent - The parent activity.
-   * @param {Object} processPayload - The processed data.
-   * @param {number} deepestLevel - The deepest level found.
-   * @param {Set<number>} allLevels - Set of all levels.
-   * @returns {Object} The result object.
-   */
   createResult(parent, processPayload, deepestLevel, allLevels) {
     const { activitiesByLevel, parentsIds, allTasks } = processPayload;
     return {
@@ -5854,22 +6200,6 @@ var CriticalPathHelpers = class {
       throw e;
     }
   }
-  /**
-   * Identifies and sets the initial activities for the chain based on the specified direction.
-   *
-   * This function determines the starting activities of a chain by filtering activities from
-   * the Gantt chart. The filtering is based on the specified direction (`forward` or `backward`).
-   * - For `forward` direction, activities with an empty `$target` property are selected.
-   * - For `backward` direction, activities with an empty `$source` property are selected.
-   *
-   * The function excludes activities of type `project` from the results.
-   * The resulting activity IDs are stored in the `chainStartActivities` property.
-   *
-   * If an error occurs during the process, `chainStartActivities` is set to an empty array,
-   * and the error is rethrown.
-   *
-   * @throws {Error} If an error occurs during the identification process.
-   */
   identifyInitialActivities() {
     try {
       const {
@@ -5980,27 +6310,6 @@ var CriticalPathHelpers = class {
     }
     return sorted.reverse();
   }
-  /**
-    * Calculates the start and finish dates for the origin of a chain activity.
-    *
-    * This function calculates the start and finish dates for an activity based on the provided direction
-    * (`forward` or `backward`). For forward direction, it calculates the earliest start (ES) and earliest
-    * finish (EF). For backward direction, it calculates the latest start (LS) and latest finish (LF),
-    * handling different progress states (0%, 100%, and between 0% and 100%).
-    *
-    * @param {Object} [activityFromLink=null] - The activity object to calculate dates for.
-    * @param {string} [customDirection=null] - The direction for the calculation (`forward` or `backward`).
-    * @returns {Object} An object containing the calculated dates (ES, EF, LS, LF) based on the direction and progress.
-    *
-    * @example
-    * // Assuming activity is an object with start_date, end_date, progress, and calendar_id properties
-    * // and direction is 'forward'
-    * const dates = calculateStartAndFinishOfChainOrigin(activity, 'forward');
-    * console.log()
-  // { es: activity.start_date, ef: activity.end_date }
-    *
-    * @throws {Error} If the activity's calendar cannot be retrieved or other errors occur during calculation.
-    */
   calculateStartAndFinishOfChainOrigin(activityFromLink = null, customDirection = null) {
     try {
       let activity = activityFromLink;
@@ -6046,25 +6355,6 @@ var CriticalPathHelpers = class {
       throw e;
     }
   }
-  /**
-    * Calculates the latest start (LS) and latest finish (LF) dates for an activity with zero progress.
-    *
-    * This function determines the LS and LF dates based on the activity's constraint type and duration,
-    * using the provided calendar. It handles different types of constraints, adjusting the start and finish
-    * dates accordingly.
-    *
-    * @param {Object} activity - The activity object to calculate dates for, which should include start_date, end_date, duration, and constraint_type.
-    * @param {Object} calendar - The calendar object used to adjust dates based on working days and hours.
-    * @returns {Object} An object containing the calculated latest start (LS) and latest finish (LF) dates.
-    *
-    * @example
-    * // Assuming activity is an object with the required properties and a calendar object is provided
-    * const dates = calculateBackwardWhenZeroProgress(activity, calendar);
-    * console.log()
-  // { ls: moment(...), lf: moment(...) }
-    *
-    * @throws {Error} If an error occurs during the calculation.
-    */
   calculateBackwardWhenZeroProgress(activity, calendar) {
     let lateStart = moment_default(activity.start_date).clone();
     let lateFinish = moment_default(activity.end_date).clone();
@@ -6101,23 +6391,6 @@ var CriticalPathHelpers = class {
       lf: lateFinish
     };
   }
-  /**
-    * Calculates the latest start (LS) and latest finish (LF) dates for an activity with progress between 0% and 100%.
-    *
-    * This function determines the LS and LF dates based on the activity's constraint type and progress,
-    * considering the end date of the project and various constraints.
-    *
-    * @param {Object} activity - The activity object to calculate dates for, which should include start_date, end_date, and constraint_type.
-    * @returns {Object} An object containing the calculated latest start (LS) and latest finish (LF) dates.
-    *
-    * @example
-    * // Assuming activity is an object with the required properties
-    * const dates = calculateWhenProgressIsBetweenZeroAndOneHundred(activity);
-    * console.log()
-  // { ls: activity.start_date, lf: calculatedLateFinish }
-    *
-    * @throws {Error} If an error occurs during the calculation.
-    */
   calculateWhenProgressIsBetweenZeroAndOneHundred(activity) {
     let lateStart = activity.start_date;
     let lateFinish = null;
@@ -6178,7 +6451,6 @@ var CriticalPathHelpers = class {
       throw e;
     }
   }
-  // Main function
   doCalculationForParentType(activity) {
     const calculationOfParent = new calculation_of_parent_default({
       activity,
@@ -6256,22 +6528,6 @@ var LinksRulesCalculationsMethods = class {
     this.parentsCalculations = calculationObject.parentsCalculations;
     this.gantt = calculationObject.ganttInstance;
   }
-  /**
-    * Retrieves the earliest start (ES) and earliest finish (EF) dates for a given activity from previously calculated activities.
-    *
-    * This function checks if the activity exists in the `alapMap`. If it does, it returns the data from `alapMap`.
-    * If the activity is not found in `alapMap`, it retrieves and returns the data from `calculatedActivities`.
-    *
-    * @param {string|number} activity - The ID of the activity for which to retrieve ES and EF dates.
-    * @returns {Object|null} The ES and EF dates for the activity, or null if not found.
-    *
-    * @example
-    * // Assuming alapMap and calculatedActivities are Maps with activity data
-    * const esEf = getEsAndEfFromPreviousCalculatedActivities(1);
-  // { es: ..., ef: ..., text: ... } or null
-    *
-    * @throws {Error} If an error occurs during the retrieval process.
-    */
   getEsAndEfFromPreviousCalculatedActivities(activity) {
     const isAlap = this.alapMap.has(activity);
     if (isAlap) {
@@ -6279,29 +6535,6 @@ var LinksRulesCalculationsMethods = class {
     }
     return this.calculatedActivities.get(Number(activity));
   }
-  /**
-    * Calculates the earliest start (ES) and earliest finish (EF) times for a successor activity.
-    *
-    * This function calculates the ES and EF times for a successor activity based on the provided predecessor time,
-    * data calculations for ES and EF, lag time, and the type of link restriction. It adjusts the dates according
-    * to the activity's calendar and the specified restrictions.
-    *
-    * @param {Date} predecessorTime - The time of the predecessor activity.
-    * @param {number} esDataCalculation - The amount of time to add to the predecessor time to calculate the earliest start.
-    * @param {number} [efDataCalculation=0] - The amount of time to add to calculate the earliest finish.
-    * @param {number} lag - The lag time between the predecessor and successor activities.
-    * @param {string} [restrictionOfLink='fs'] - The type of link restriction between the activities.
-    * @returns {Object} An object containing the calculated earliest start (ES) and earliest finish (EF) times.
-    * @property {Date} es - The earliest start time.
-    * @property {Date} ef - The earliest finish time.
-    *
-    * @example
-    * // Assuming predecessorTime is a Date object, esDataCalculation is 5, efDataCalculation is 10, lag is 2, and restrictionOfLink is 'fs'
-    * const result = calculateSucessorTimes(new Date(), 5, 10, 2, 'fs');
-  // { es: Date, ef: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateSucessorTimes(predecessorTime, esDataCalculation, efDataCalculation = 0, lag, restrictionOfLink = LINK_TYPES.FS) {
     const activityCalendar = this.gantt.getCalendar(
       this.referenceActivity.calendar_id
@@ -6374,27 +6607,6 @@ var LinksRulesCalculationsMethods = class {
     }
     return { es, ef };
   }
-  /**
-    * Calculates the earliest start (ES) and earliest finish (EF) times for a Start-to-Start (SS) relationship.
-    *
-    * This function calculates the ES and EF times for a successor activity based on a Start-to-Start (SS) relationship
-    * with the predecessor activity. It uses the predecessor's ES time and adjusts it based on the link's lag and the
-    * activity's duration.
-    *
-    * @param {Object} link - The link object representing the relationship between the predecessor and successor activities.
-    * @param {number} link.source - The ID of the predecessor activity.
-    * @param {number} [link.lag=0] - The lag time between the predecessor and successor activities.
-    * @returns {Object} An object containing the calculated earliest start (ES) and earliest finish (EF) times.
-    * @property {Date} es - The earliest start time.
-    * @property {Date} ef - The earliest finish time.
-    *
-    * @example
-    * // Assuming link is an object with a source property (predecessor ID) and an optional lag property
-    * const result = calculateSS({ source: 1, lag: 2 });
-  // { es: Date, ef: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateSS(link) {
     const predecessorCalculatedEsAndEf = this.getEsAndEfFromPreviousCalculatedActivities(Number(link.source));
     const esDataCalculation = link.lag || 0;
@@ -6409,27 +6621,6 @@ var LinksRulesCalculationsMethods = class {
       LINK_TYPES.SS
     );
   }
-  /**
-    * Calculates the earliest start (ES) and earliest finish (EF) times for a Finish-to-Finish (FF) relationship.
-    *
-    * This function calculates the ES and EF times for a successor activity based on a Finish-to-Finish (FF) relationship
-    * with the predecessor activity. It uses the predecessor's EF time and adjusts it based on the link's lag and the
-    * activity's duration.
-    *
-    * @param {Object} link - The link object representing the relationship between the predecessor and successor activities.
-    * @param {number} link.source - The ID of the predecessor activity.
-    * @param {number} [link.lag=0] - The lag time between the predecessor and successor activities.
-    * @returns {Object} An object containing the calculated earliest start (ES) and earliest finish (EF) times.
-    * @property {Date} es - The earliest start time.
-    * @property {Date} ef - The earliest finish time.
-    *
-    * @example
-    * // Assuming link is an object with a source property (predecessor ID) and an optional lag property
-    * const result = calculateFF({ source: 1, lag: 2 });
-  // { es: Date, ef: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateFF(link) {
     const predecessorCalculatedEsAndEf = this.getEsAndEfFromPreviousCalculatedActivities(Number(link.source));
     const duration = this.referenceActivity.duration;
@@ -6444,27 +6635,6 @@ var LinksRulesCalculationsMethods = class {
       LINK_TYPES.FF
     );
   }
-  /**
-    * Calculates the earliest start (ES) and earliest finish (EF) times for a Finish-to-Start (FS) relationship.
-    *
-    * This function calculates the ES and EF times for a successor activity based on a Finish-to-Start (FS) relationship
-    * with the predecessor activity. It uses the predecessor's EF time and adjusts it based on the link's lag and the
-    * activity's duration.
-    *
-    * @param {Object} link - The link object representing the relationship between the predecessor and successor activities.
-    * @param {number} link.source - The ID of the predecessor activity.
-    * @param {number} [link.lag=0] - The lag time between the predecessor and successor activities.
-    * @returns {Object} An object containing the calculated earliest start (ES) and earliest finish (EF) times.
-    * @property {Date} es - The earliest start time.
-    * @property {Date} ef - The earliest finish time.
-    *
-    * @example
-    * // Assuming link is an object with a source property (predecessor ID) and an optional lag property
-    * const result = calculateFS({ source: 1, lag: 2 });
-  // { es: Date, ef: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateFS(link) {
     const predecessorCalculatedEsAndEf = this.getEsAndEfFromPreviousCalculatedActivities(Number(link.source));
     const esDataCalculation = link.lag || 0;
@@ -6479,27 +6649,6 @@ var LinksRulesCalculationsMethods = class {
       LINK_TYPES.FS
     );
   }
-  /**
-    * Calculates the earliest start (ES) and earliest finish (EF) times for a Start-to-Finish (SF) relationship.
-    *
-    * This function calculates the ES and EF times for a successor activity based on a Start-to-Finish (SF) relationship
-    * with the predecessor activity. It uses the predecessor's EF time and adjusts it based on the link's lag and the
-    * activity's duration.
-    *
-    * @param {Object} link - The link object representing the relationship between the predecessor and successor activities.
-    * @param {number} link.source - The ID of the predecessor activity.
-    * @param {number} [link.lag=0] - The lag time between the predecessor and successor activities.
-    * @returns {Object} An object containing the calculated earliest start (ES) and earliest finish (EF) times.
-    * @property {Date} es - The earliest start time.
-    * @property {Date} ef - The earliest finish time.
-    *
-    * @example
-    * // Assuming link is an object with a source property (predecessor ID) and an optional lag property
-    * const result = calculateSF({ source: 1, lag: 2 });
-  // { es: Date, ef: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateSF(link) {
     const predecessorCalculatedEsAndEf = this.getEsAndEfFromPreviousCalculatedActivities(Number(link.source));
     const duration = this.referenceActivity.duration;
@@ -6514,24 +6663,6 @@ var LinksRulesCalculationsMethods = class {
       LINK_TYPES.SF
     );
   }
-  /**
-    * Adjusts a date to the next working hour based on the type of link restriction and the activity's calendar.
-    *
-    * This function adjusts the provided date either to a future or past working hour based on the specified link restriction.
-    * It uses the activity's calendar to determine the working hours and calculates the appropriate date.
-    *
-    * @param {Date} dateBaseToCalculate - The initial date that needs to be adjusted.
-    * @param {string} restrictionOfLink - The type of link restriction (e.g., 'fs', 'ss', 'ff').
-    * @param {Object} activityCalendar - The calendar associated with the activity, used to determine working hours.
-    * @returns {Date} The adjusted date based on the link restriction and activity calendar.
-    *
-    * @example
-    * // Assuming dateBaseToCalculate is a Date object, restrictionOfLink is 'fs', and activityCalendar is a valid calendar object
-    * const adjustedDate = mutateTheDateToFutureOrPastInBaseRestriction(new Date(), 'fs', activityCalendar);
-  // The date adjusted to the next working hour in the future
-    *
-    * @throws {Error} If an error occurs during the date adjustment process.
-    */
   mutateTheDateToFutureOrPastInBaseRestriction(dateBaseToCalculate, restrictionOfLink, activityCalendar) {
     if (![LINK_TYPES.FS, LINK_TYPES.SS, LINK_TYPES.FF].includes(restrictionOfLink)) {
       return dateBaseToCalculate;
@@ -6555,22 +6686,6 @@ var LinksConstraintCalculator = class extends LinksRulesCalculationsMethods_defa
   constructor(calculationObject) {
     super(calculationObject);
   }
-  /**
-   * Calculates the earliest start dates for all links and returns the maximum early start set.
-   *
-   * This function processes each link in the `links` array, retrieves the necessary link data, and calculates
-   * the earliest start dates using the `calculateLink` method. It then returns the maximum early start set
-   * by calling `getMaxEarlyStartSet`.
-   *
-   * @returns {Object} The maximum early start set calculated from all links.
-   *
-   * @example
-   * // Assuming links is an array of link IDs [1, 2, 3]
-   * // and gantt.getLink(id) returns link data for each ID
-   * const result = calculate();
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   calculate() {
     if (this.links.length === 0) {
       return new generic_calculations_default(
@@ -6601,23 +6716,6 @@ var LinksConstraintCalculator = class extends LinksRulesCalculationsMethods_defa
     }
     return getMaxEarlyStartSet(allLinksCalculations);
   }
-  /**
-   * Calculates the link based on its type.
-   *
-   * This function determines the appropriate calculation method for the link based on its type and executes it.
-   * The link type is mapped to specific calculation methods: Finish-to-Start (FS), Start-to-Start (SS),
-   * Finish-to-Finish (FF), and Start-to-Finish (SF).
-   *
-   * @param {Object} linkData - The data of the link to be calculated. It should include a `type` property that indicates the type of link.
-   * @returns {*} The result of the calculation based on the link type.
-   *
-   * @example
-   * // Assuming linkData is an object with a type property
-   * const result = calculateLink({ type: 0, ...otherLinkProperties });
-   * // This will call the calculateFS method with the linkData and return the result
-   *
-   * @throws {Error} If the link type is not recognized.
-   */
   calculateLink(linkData) {
     const calculationMapping = {
       0: () => this.calculateFS(linkData),
@@ -6643,11 +6741,6 @@ var ActivityCalculator = class {
     this.linkProperty = options.linkProperty;
     this.linkDirection = options.linkDirection;
   }
-  /**
-   * Checks which activities can now be calculated based on their dependencies.
-   * @param {Set<number>} pendingToCalculate - Set of activity IDs pending calculation.
-   * @returns {Object} An object containing activities that can be calculated and remaining pending activities.
-   */
   checkActivitiesThatNowCanBeCalculated(pendingToCalculate) {
     const activitiesThatCanBeCalculated = /* @__PURE__ */ new Set();
     const pendingActivities = new Set(pendingToCalculate);
@@ -6674,9 +6767,6 @@ var ActivityCalculator = class {
       pendingActivities
     };
   }
-  /**
-   * Handles logic for project-type activities.
-   */
   handleProjectActivity(activityId, activityData, activitiesThatCanBeCalculated, pendingActivities) {
     const isPendingParentWithNoLinks = this.pendingParentsWithNoLinks.has(activityId);
     const isPendingParentWithLinks = this.pendingParentsWithLinks.has(activityId);
@@ -6717,9 +6807,6 @@ var ActivityCalculator = class {
       }
     }
   }
-  /**
-   * Determines if a parent activity can be calculated.
-   */
   canCalculateParentActivity(activityData) {
     const hasNoLinks = (activityData[this.linkProperty] || []).length === 0;
     const constraintType = activityData.constraint_type;
@@ -6734,9 +6821,6 @@ var ActivityCalculator = class {
       (activityId) => this.calculations.has(activityId)
     );
   }
-  /**
-   * Handles logic for non-project activities.
-   */
   handleNonProjectActivity(activityId, activityData, activitiesThatCanBeCalculated, pendingActivities) {
     const parentId = Number(activityData.parent);
     const isParentPendingWithLinks = this.pendingParentsWithLinks.has(parentId);
@@ -6774,9 +6858,6 @@ var ActivityCalculator = class {
       pendingActivities.delete(activityId);
     }
   }
-  /**
-   * Retrieves linked activities based on link property.
-   */
   getLinkedActivities(predecessors) {
     if (!Array.isArray(predecessors)) {
       return [];
@@ -6795,9 +6876,6 @@ var ActivityCalculator = class {
     }
     return linkedActivities;
   }
-  /**
-   * Retrieves an array of linked activity IDs.
-   */
   getArrayOfLinkedActivities(links) {
     if (!Array.isArray(links)) {
       return [];
@@ -6819,8 +6897,7 @@ var get_activities_to_calculate_default = ActivityCalculator;
 var createIsCurrent2 = (calculationId, getCurrentId) => () => getCurrentId() === calculationId;
 
 // src/critical-path/legacy/utils/validation.js
-var shouldAbortCalculation = (gantt) => !gantt?.fullyParsed || // environment guard: en el core no hay `window` (el bridge en react_client sí).
-typeof window !== "undefined" && window.to_use_react_gantt?.conversionMode?.isActive;
+var shouldAbortCalculation = (gantt) => !gantt?.fullyParsed || typeof window !== "undefined" && window.to_use_react_gantt?.conversionMode?.isActive;
 
 // src/critical-path/legacy/utils/timing.js
 var TIME_BUDGET_MS = 16;
@@ -6932,24 +7009,6 @@ var ForwardPath = class extends generic_calculations_default {
       isCurrent
     });
   }
-  /**
-   * Calculates the earliest start (ES) and earliest finish (EF) dates for a list of activities.
-   *
-   * This function processes each activity in the `activitiesToCalculate` list, retrieves the necessary
-   * information, and calculates the ES and EF dates based on the activity's progress and constraint type.
-   * It handles various constraints and updates the calculations accordingly.
-   * It also do calculation according to the activities links
-   *
-   * @param {Array<string|number>} activitiesToCalculate - A list of activity IDs for which to calculate ES and EF dates.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activitiesToCalculate is an array containing activity IDs [1, 2, 3]
-   * calculateStartAndFinishTimes([1, 2, 3]);
-   * // This will calculate the ES and EF dates for the activities and update the internal calculations map.
-   *
-   * @throws {Error} If an error occurs during the process.
-   */
   calculateStartAndFinishTimes(activitiesToCalculate) {
     activitiesToCalculate.forEach((activity) => {
       const activityReference = this.gantt.getTask(activity);
@@ -7070,13 +7129,6 @@ var ForwardPath = class extends generic_calculations_default {
       this.activitiesWaitingForCalculation.delete(activity);
     });
   }
-  /**
-   * Gets the greatest date between a restriction and a link calculation.
-   * @param {Object} restriction - The restriction object.
-   * @param {Object} linkCalculation - The link calculation object.
-   * @param {string} [comparisonType='greater'] - The type of comparison ('greater' or 'less').
-   * @returns {Object} - The object with the greatest date.
-   */
   getTheGreatesDateBetweenRestrictionAndEsEf(restriction, linkCalculation, comparisonType = "greater") {
     if (comparisonType === "greater") {
       return linkCalculation.ef > restriction.ef ? linkCalculation : restriction;
@@ -7085,34 +7137,18 @@ var ForwardPath = class extends generic_calculations_default {
       return linkCalculation.ef < restriction.ef ? linkCalculation : restriction;
     }
   }
-  /**
-   * Set ES and EF dates for an activity with full progress.
-   * @param {Object} activity - The activity object.
-   */
   setDatesForActivityWithFullProgress(activity) {
     this.calculations.set(activity.id, {
       es: activity.start_date,
       ef: activity.end_date
     });
   }
-  /**
-   * Calculates ES and EF dates for an activity with progress greater than zero.
-   * @param {Object} activity - The activity object.
-   * @returns {Object} - The calculated ES and EF dates.
-   */
   getDatesForActivityWithZeroProgress(activity) {
     return {
       es: activity.start_date,
       ef: activity.end_date
     };
   }
-  /**
-   * Recalculates ES and EF dates based on a constraint.
-   * @param {string} constraintType - The type of constraint.
-   * @param {Object} calculatedRestriction - The calculated restriction object.
-   * @param {Object} calculatedEsEf - The calculated ES and EF object.
-   * @returns {Object} - The recalculated ES and EF dates.
-   */
   recalculateInBaseConstraint(constraintType, calculatedRestriction, calculatedEsEf) {
     const comparisontype = [
       CONSTRAINT_TYPES.SNET,
@@ -7152,30 +7188,12 @@ var CalculationsGenericMethods = class {
     this.forwardPathCalculations = calculationObject.calculatedForwardActivitiesMap;
     this.gantt = calculationObject.ganttInstance;
   }
-  /**
-   * Retrieves the late start (LS) and late finish (lf) dates for a given activity from previously calculated activities.
-   *
-   * @param {string|number} activity - The ID of the activity for which to retrieve LS and lf dates.
-   * @param {string} [constraint=null] - The constraint type to use for the calculation (e.g., 'alap').
-   * @returns {Object|null} The LS and lf dates for the activity, or null if not found.
-   * @throws {Error} If an error occurs during the retrieval process.
-   */
   getForwardOrBackwardCalculations(activity, constraint = null) {
     if (constraint === CONSTRAINT_TYPES.ALAP) {
       return this.forwardPathCalculations.get(activity);
     }
     return this.calculatedActivities.get(activity);
   }
-  /**
-   * Calculates the LS (Latest Start) and LF (Latest Finish) times for the successor activity.
-   * @param {Date} successorTime - The time of the successor activity.
-   * @param {number} lsDataCalculation - The duration for LS calculation.
-   * @param {number} [lfDataCalculation=0] - The duration for LF calculation, default is 0.
-   * @param {number} lag - The lag time.
-   * @param {string} [type='FS'] - The type of link ('FS', 'FF', 'SS', 'SF'), default is 'FS'.
-   * @returns {Object} Returns an object containing the LS and LF times for the successor activity.
-   * @throws Will throw an error if there's an issue with the calculation.
-   */
   calculateSuccessorTimes(sucessorTime, lsDataCalculation, lfDataCalculation = 0, lag, type = LINK_TYPES.FS) {
     let activityCalendar = this.gantt.getCalendar(this.activity.calendar_id);
     if (!activityCalendar) {
@@ -7225,13 +7243,6 @@ var CalculationsGenericMethods = class {
       return { ls, lf };
     }
   }
-  /**
-   * Calculates the LS (Latest Start) and LF (Latest Finish) times for the successor activity in a SS (Start-to-Start) link.
-   * @param {Object} link - The link object containing information about the relationship.
-   * @param {boolean} [alap=false] - Indicates whether to calculate based on ALAP (As Late As Possible) constraint, default is false.
-   * @returns {Object} Returns an object containing the calculated LS and LF times for the successor activity.
-   * @throws Will throw an error if there's an issue with the calculation.
-   */
   calculateSS(link, alap = false) {
     let lsSuc = this.getValueForSS(link, alap);
     let lsDataForCalculation = -link.lag || 0;
@@ -7245,12 +7256,6 @@ var CalculationsGenericMethods = class {
       LINK_TYPES.SS
     );
   }
-  /**
-   * Calculates the LS (Latest Start) and LF (Latest Finish) times for the successor activity in a FF (Finish-to-Finish) link.
-   * @param {Object} link - The link object containing information about the relationship.
-   * @returns {Object} Returns an object containing the calculated LS and LF times for the successor activity.
-   * @throws Will throw an error if there's an issue with the calculation.
-   */
   calculateFF(link, constraint) {
     const succesorDate = this.getForwardOrBackwardCalculations(
       Number(link.target)
@@ -7268,13 +7273,6 @@ var CalculationsGenericMethods = class {
       LINK_TYPES.FF
     );
   }
-  /**
-   * Calculates the LS (Latest Start) and LF (Latest Finish) times for the successor activity in a FS (Finish-to-Start) link.
-   * @param {Object} link - The link object containing information about the relationship.
-   * @param {string} constraint - The constraint type.
-   * @returns {Object} Returns an object containing the calculated LS and LF times for the successor activity.
-   * @throws Will throw an error if there's an issue with the calculation.
-   */
   calculateFS(link, constraint) {
     let propertyToCalculate = "ls";
     propertyToCalculate = constraint === CONSTRAINT_TYPES.ALAP ? "es" : "ls";
@@ -7293,13 +7291,6 @@ var CalculationsGenericMethods = class {
       LINK_TYPES.FS
     );
   }
-  /**
-   * Calculates the LS (Latest Start) and LF (Latest Finish) times for the successor activity in a SF (Start-to-Finish) link.
-   * @param {Object} link - The link object containing information about the relationship.
-   * @param {boolean} getFromForward - Whether to calculate LS using the early start from the forward path.
-   * @returns {Object} Returns an object containing the calculated LS and LF times for the successor activity.
-   * @throws Will throw an error if there's an issue with the calculation.
-   */
   calculateSF(link, getFromForward = false) {
     let lateFinishSucessor = getFromForward ? this.getEarlyStartFromForwardPath(Number(link.target)).ef : this.getForwardOrBackwardCalculations(Number(link.target)).lf;
     let lsDataForCalculation = -link.lag || 0;
@@ -7313,19 +7304,9 @@ var CalculationsGenericMethods = class {
       LINK_TYPES.SF
     );
   }
-  /**
-   * Retrieves the early start time from the forward path calculations for the current activity.
-   * @returns {number} The early start time for the activity.
-   */
   getEarlyStartFromForwardPath(link) {
     return this.forwardPathCalculations.get(link);
   }
-  /**
-   * Retrieves the value for the specified scheduling state (SS).
-   * @param {object} link - The link object representing the dependency.
-   * @param {boolean} alap - Flag indicating if the scheduling state is As Late As Possible (ALAP).
-   * @returns {number} The value representing the specified scheduling state.
-   */
   getValueForSS(link, alap) {
     if (alap) {
       return this.getEarlyStartFromForwardPath(Number(link.target)).es;
@@ -7334,13 +7315,6 @@ var CalculationsGenericMethods = class {
     let sucessor = this.getForwardOrBackwardCalculations(Number(link.target));
     return sucessor[propertyToCalculate];
   }
-  /**
-   * Calculates the end date based on the provided activity calendar, starting date, and duration.
-   * @param {object} activityCalendar - The calendar object containing activity scheduling information.
-   * @param {Date} date - The starting date for the activity.
-   * @param {number} duration - The duration of the activity in days.
-   * @returns {Date} The end date of the activity.
-   */
   calculateDate(activityCalendar, date2, duration) {
     let resetedDate = moment_default(date2).clone();
     return addDurationToDate(
@@ -7350,14 +7324,6 @@ var CalculationsGenericMethods = class {
       this.activity
     );
   }
-  /**
-   * Retrieves the last working hour based on the provided date and activity calendar.
-   * @param {Date} date - The date for which to find the last working hour.
-   * @param {object} activityCalendar - The calendar object containing activity scheduling information.
-   * @param {string} [dir='past'] - The direction in which to search for the last working hour. Default is 'past'.
-   * @throws {Error} Throws an error if the provided date is not valid.
-   * @returns {Date} The last working hour relative to the provided date.
-   */
   getLastWorkingHour(date2, activityCalendar, dir = "past") {
     const normalizedDate = date2 instanceof Date ? date2 : new Date(date2);
     let resetedDate = moment_default(normalizedDate).clone();
@@ -7372,14 +7338,6 @@ var CalculationsGenericMethods = class {
     });
     return newDate;
   }
-  /**
-   * Determines if a given date corresponds to the initial work hour of an activity as defined in the activity calendar.
-   * This function retrieves the first work interval from the activity calendar and compares the hour portion
-   * of the input date to the start hour of the work interval.
-   * @param {object} activityCalendar - The calendar object containing work hours and scheduling information for the activity.
-   * @param {Date} date - The date to check against the activity's start hour.
-   * @returns {boolean} True if the hour of the input date matches the initial work hour of the activity; otherwise, false.
-   */
   isActivityInInitHour(activityCalendar, date2) {
     const normalizedDate = date2 instanceof Date ? date2 : new Date(date2);
     const shifts = activityCalendar.getWorkHours(normalizedDate);
@@ -7398,17 +7356,6 @@ var CalculationsGenericMethods = class {
     }
     return normalizedDate.getUTCHours() === workStartHour;
   }
-  /**
-   * Calculates the forward start (FS) and forward finish (FF) dates based on the provided parameters.
-   * @param {object} options - An object containing the necessary parameters for the calculation.
-   * @param {number} options.lag - The lag duration for the calculation.
-   * @param {Date} options.workTime - The starting work time for the calculation.
-   * @param {object} options.activityCalendar - The calendar object containing activity scheduling information.
-   * @param {number} options.lsDataCalculation - The duration for calculating the forward start date.
-   * @param {number} options.lfDataCalculation - The duration for calculating the forward finish date.
-   * @param {boolean} [options.isMilestone=false] - Flag indicating if the activity is a milestone. Default is false.
-   * @returns {object} An object containing the forward start (FS) and forward finish (FF) dates.
-   */
   calculateFsLink({
     lag,
     workTime,
@@ -7461,16 +7408,6 @@ var CalculationsGenericMethods = class {
     }
     return { ls: lsPred, lf: lfPred };
   }
-  /**
-   * Calculates the forward finish (FF) dates based on the provided parameters.
-   * @param {object} options - An object containing the necessary parameters for the calculation.
-   * @param {number} options.lag - The lag duration for the calculation.
-   * @param {Date} options.workTime - The starting work time for the calculation.
-   * @param {object} options.activityCalendar - The calendar object containing activity scheduling information.
-   * @param {number} options.lsDataCalculation - The duration for calculating the forward start date.
-   * @param {number} options.lfDataCalculation - The duration for calculating the forward finish date.
-   * @returns {object} An object containing the forward start (FS) and forward finish (FF) dates.
-   */
   calculateFFLink({
     lag,
     workTime,
@@ -7517,19 +7454,6 @@ var CalculationsGenericMethods = class {
     );
     return { ls: lsPred, lf: lfPred };
   }
-  /**
-   * Calculates the start and finish times for an activity based on the specified lag and work time.
-   * If the lag is zero, the function directly calculates the times using the provided work time.
-   * If the lag is negative and the activity is not a milestone, it adjusts the work time based on future working hours.
-   * @param {object} options - Configuration object containing parameters needed for the calculation.
-   * @param {number} options.lay - The lag time affecting the start and finish calculations.
-   * @param {Date} options.workTime - The reference time from which calculations begin.
-   * @param {object} options.activityCalendar - The calendar used to check work hours and holidays.
-   * @param {number} options.lsDataCalculation - Duration to calculate the start time from the reference point.
-   * @param {number} options.lfDataCalculation - Duration to calculate the finish time from the calculated start time.
-   * @param {boolean} [options.isMilestone=false] - Indicates whether the current activity is a milestone.
-   * @returns {object} An object with properties `ls` (start time) and `lf` (finish time).
-   */
   calculateSSlink({
     lag,
     workTime,
@@ -7577,17 +7501,6 @@ var CalculationsGenericMethods = class {
     );
     return { ls: lsPred, lf: lfPred };
   }
-  /**
-   * Calculates the start (SF) and finish (LF) times for an activity based on the specified lag and work time.
-   * This function handles both cases where lag is zero and when it's not, calculating times based on the given work time.
-   * @param {object} options - Configuration object containing the necessary parameters for the calculation.
-   * @param {number} options.lag - The lag time that influences the scheduling.
-   * @param {Date} options.workBlock - The reference time from which scheduling starts.
-   * @param {object} options.activityCalendar - The calendar object containing activity scheduling information.
-   * @param {number} options.lsDataCalculation - The duration to calculate the start time.
-   * @param {number} options.lfDataCalculation - The duration to calculate the finish time.
-   * @returns {object} An object containing the start (ls) and finish (lf) times of the activity.
-   */
   calculateSFLink({
     lag,
     workTime,
@@ -7634,23 +7547,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
     this.parentsThatImpactChildrens = calculationObject.parentsThatImpactChildrens;
     this.projectDates = this.gantt.getSubtaskDates();
   }
-  /**
-    * Calculates the latest start (LS) and latest finish (LF) times for an activity.
-    *
-    * This function calculates the LS and LF times for an activity based on its progress and the links associated with it.
-    * It takes into account various conditions and constraints to determine the final LS and LF times.
-    *
-    * @returns {Object} An object containing the calculated latest start (LS) and latest finish (LF) times.
-    * @property {Date} ls - The calculated latest start time.
-    * @property {Date} lf - The calculated latest finish time.
-    *
-    * @example
-    * // Assuming this function is part of a class with access to the required properties and methods
-    * const result = calculate();
-  // { ls: Date, lf: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculate() {
     if (this.links.length === 0) {
       return new generic_calculations_default(
@@ -7727,11 +7623,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       minFromLinks: calculation
     };
   }
-  /**
-   * Calculates the Late Start (LS) and Late Finish (LF) for the current activity.
-   * @returns {Object} An object containing the Late Start (LS) and Late Finish (LF) dates.
-   * @throws {Error} If there's an issue with retrieving the calendar or calculating the dates.
-   */
   calculateTheLsAndLfForTheActivity(parentDates = null) {
     try {
       const duration = this.activity.duration;
@@ -7758,12 +7649,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       throw Error(error.message);
     }
   }
-  /**
-   * Calculates the minimum between the minimum date from links and the end date of the project
-   * or the end date of the activity, depending on the constraint type.
-   * @param {Object} minCalculatedDateFromLinks - The minimum calculated date from links.
-   * @returns {Date} The minimum date between the calculated date from links and the end date.
-   */
   SnetSnltMsoMinDate(minCalculatedDateFromLinks) {
     const minDateOfEndOfProjectAndLinks = Math.min(
       minCalculatedDateFromLinks.lf,
@@ -7773,12 +7658,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       Math.max(minDateOfEndOfProjectAndLinks, this.activity.end_date)
     );
   }
-  /**
-   * Calculates the successor and/or predecessor times based on the link type and constraints.
-   * @param {Object} linkData - The link data object containing information about the link.
-   * @returns {void} Returns nothing if the calculation is avoided based on the progress of the target activity.
-   * @throws {Error} Throws an error if activity data is not found or if an error occurs during calculation.
-   */
   calculateLink(linkData) {
     const activityFromLink = this.gantt.getTask(linkData.target);
     if (!activityFromLink) {
@@ -7798,29 +7677,17 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
     };
     return calculationMapping[linkData.type]();
   }
-  /**
-   * Determines the special calculation parameter based on the constraint type.
-   * @returns {string|undefined} Returns a special parameter for specific constraint types, or undefined if no special parameter is needed.
-   */
   getSpecialCalculationParamForConstraintLink() {
     if (this.constraint === CONSTRAINT_TYPES.ALAP) return CONSTRAINT_TYPES.ALAP;
     if (this.constraint === CONSTRAINT_TYPES.FNET || this.constraint === CONSTRAINT_TYPES.SNET)
       return "snet-fnet";
     if (this.constraint === CONSTRAINT_TYPES.FNLT) return CONSTRAINT_TYPES.FNLT;
   }
-  /**
-   * Determines the special calculation parameter based on the constraint type.
-   * @returns {string|undefined} Returns a special parameter for specific constraint types, or undefined if no special parameter is needed.
-   */
   getSpecialParamForSf() {
     const constriantThatNeedSpecialParam = [CONSTRAINT_TYPES.ALAP];
     if (constriantThatNeedSpecialParam.includes(this.constraint)) return true;
     return false;
   }
-  /**
-   * Determines the special calculation parameter based on the constraint type.
-   * @returns {string|undefined} Returns a special parameter for specific constraint types, or undefined if no special parameter is needed.
-   */
   getSpecialParamForFF() {
     const constraintsThatNeedSpecialFFParam = [
       CONSTRAINT_TYPES.MFO,
@@ -7830,11 +7697,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       return true;
     return false;
   }
-  /**
-   * Determines the minimum calculation logic based on the constraint type.
-   * @param {Object} minCalculateFromLinks - The minimum calculation data from links.
-   * @returns {Date} Returns the minimum calculation date based on the constraint type.
-   */
   getMinCalculationLogic(minCalculateFromLinks) {
     if (this.constraint === CONSTRAINT_TYPES.ALAP) {
       return this.getMinDateBasedOnConstraint(minCalculateFromLinks);
@@ -7855,11 +7717,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       return this.getMinDateBasedOnConstraint(minCalculateFromLinks);
     }
   }
-  /**
-   * Calculates the minimum date from the list of link calculations based on the constraint type.
-   * @param {Array} allLinksCalculations - The list of all link calculations.
-   * @returns {Object} Returns the minimum date from the link calculations.
-   */
   getMinDateFromLinks(allLinksCalculations) {
     try {
       if (this.constraint === CONSTRAINT_TYPES.ALAP || this.constraint === CONSTRAINT_TYPES.ASAP) {
@@ -7882,16 +7739,6 @@ var LinksConstraintCalculator2 = class extends CalculationsGenericMethods_defaul
       (min, activity) => activity.lf < min.lf ? activity : min
     );
   }
-  /**
-   * Gets the minimum date between the links' minimum date and the end of the project based on the constraint type.
-   *
-   * @param {Object} minCalculatedDateFromLinks - The minimum calculated date from links.
-   * @param {Date} minCalculatedDateFromLinks.lf - The latest finish date from links.
-   * @param {string} constraintType - The constraint type of the activity.
-   * @returns {Date} The calculated minimum date based on the constraint type.
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   getMinDateBasedOnConstraint(minCalculatedDateFromLinks, constraintType = this.constraint) {
     const minDateOfEndOfProjectAndLinks = Math.min(
       minCalculatedDateFromLinks.lf,
@@ -8042,23 +7889,6 @@ var BackwardPath = class extends generic_calculations_default {
       lf: maxLf
     });
   }
-  /**
-   * Calculates the latest start (LS) and latest finish (LF) times for a list of activities.
-   *
-   * This function processes each activity in the `activitiesToCalculate` list, retrieves the necessary
-   * information, and calculates the LS and LF times based on the activity's progress and constraint type.
-   * It handles various constraints and updates the calculations accordingly.
-   *
-   * @param {Array<string|number>} activitiesToCalculate - A list of activity IDs for which to calculate LS and LF times.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activitiesToCalculate is an array containing activity IDs [1, 2, 3]
-   * calculateStartAndFinishTimes([1, 2, 3]);
-   * // This will calculate the LS and LF times for the activities and update the internal calculations map.
-   *
-   * @throws {Error} If an error occurs during the process.
-   */
   calculateStartAndFinishTimes(activitiesToCalculate) {
     activitiesToCalculate.forEach((activityId) => {
       let activityReference = this.gantt.getTask(activityId);
@@ -8136,29 +7966,6 @@ var BackwardPath = class extends generic_calculations_default {
       });
     });
   }
-  /**
-    * Determines the least late time for an activity based on ES and EF constraints.
-    *
-    * This function compares the latest finish (LF) time from links with the earliest finish (EF) constraint
-    * for the activity. If the LF from links is less than the EF constraint, it returns the LF from links.
-    * Otherwise, it returns the ES and EF constraints.
-    *
-    * @param {string|number} activity - The ID of the activity.
-    * @param {Object} lfFromLinks - An object containing LS (latest start) and LF (latest finish) times from links.
-    * @param {Date} lfFromLinks.ls - The latest start time from links.
-    * @param {Date} lfFromLinks.lf - The latest finish time from links.
-    * @returns {Object} An object containing the least late LS and LF times.
-    * @property {Date} ls - The least late latest start time.
-    * @property {Date} lf - The least late latest finish time.
-    *
-    * @example
-    * // Assuming forwardConstraintsMap contains the ES and EF constraints for the activity
-    * const result = getTheLessLateInBasEsEfConstraint(1, { ls: new Date(), lf: new Date() });
-    * console.log()
-  // { ls: Date, lf: Date }
-    *
-    * @throws {Error} If an error occurs during the process.
-    */
   getTheLessLateInBasEsEfConstraint(activity, lfFromLinks, constraintType) {
     let esEfFromConstraint = this.forwardConstraintsMap.get(activity);
     if (!esEfFromConstraint) {
@@ -8177,23 +7984,6 @@ var BackwardPath = class extends generic_calculations_default {
     }
     return { ls: esEfFromConstraint.es, lf: esEfFromConstraint.ef };
   }
-  /**
-    * Checks whether all activities linked to the given set of activities have progress greater than 0.
-    *
-    * This function iterates over the linked activities, retrieves their data, and checks if all of them have progress greater than 0.
-    * If any linked activity has 0 progress, the function returns false. If all linked activities have progress, it returns true.
-    *
-    * @param {Array<string|number>} linkedActivities - An array of linked activity IDs.
-    * @returns {boolean} True if all linked activities have progress greater than 0, otherwise false.
-    *
-    * @example
-    * // Assuming linkedActivities is an array containing linked activity IDs [1, 2, 3]
-    * const allHaveProgress = allLinkedActivitiesHasProgress([1, 2, 3]);
-    * console.log()
-  // true or false based on the progress of the linked activities
-    *
-    * @throws {Error} If an error occurs during the process, such as missing link data or activity data.
-    */
   allLinkedActivitiesHasProgress(linkedActivities) {
     try {
       let allLinkedHasProgress = true;
@@ -8218,46 +8008,9 @@ var BackwardPath = class extends generic_calculations_default {
       throw new Error(error.message);
     }
   }
-  /**
-   * Sets the calculations for an activity that has 100% progress.
-   *
-   * This function uses the activity's start and end dates to set the calculations for the activity.
-   * It is assumed that the activity has 100% progress.
-   *
-   * @param {Object} activity - The activity object containing the details of the activity.
-   * @param {Date} activity.start_date - The start date of the activity.
-   * @param {Date} activity.end_date - The end date of the activity.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activity is an object with start_date and end_date properties
-   * setDatesForActivityWithFullProgress({
-   *   start_date: new Date('2023-01-01'),
-   *   end_date: new Date('2023-01-10')
-   * });
-   * // This will set the calculations for the activity using its start and end dates.
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   setDatesForActivityWithFullProgress(activity) {
     this.setCalculations(activity, activity.start_date, activity.end_date);
   }
-  /**
-   * Sets the calculations for an activity when all its linked activities have progress.
-   *
-   * This function calculates the latest start (LS) and latest finish (LF) times for the activity using a backward direction,
-   * and sets these values in the internal calculations.
-   *
-   * @param {Object} activity - The activity object containing the details of the activity.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activity is an object with necessary properties for calculation
-   * setWhenAllLinkedActivitiesHasProgress(activity);
-   * // This will calculate LS and LF for the activity and set these values in the internal calculations.
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   setWhenAllLinkedActivitiesHasProgress(activity) {
     const parent = Number(activity.parent);
     let { ls, lf } = this.calculateStartAndFinishOfChainOrigin(
@@ -8274,23 +8027,6 @@ var BackwardPath = class extends generic_calculations_default {
     this.setCalculations(activity, ls, lf);
     return;
   }
-  /**
-   * Sets the calculations for an activity with progress greater than 0% but less than 100%.
-   *
-   * This function handles activities based on their constraint type when the progress is between 0% and 100%.
-   * It sets the calculations accordingly using the activity's start and end dates, or the constraint dates.
-   *
-   * @param {Object} activity - The activity object containing the details of the activity.
-   * @param {string} constraintType - The constraint type of the activity, such as 'mso' or 'mfo'.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activity is an object with start_date, end_date, and constraint_date properties, and constraintType is 'mso'
-   * setWhenActivitiesHasProgressButLessThanOneHundred(activity, 'mso');
-   * // This will set the calculations for the activity using its start and end dates.
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   setWhenActivitiesHasProgressButLessThanOneHundred(activity, constraintType) {
     if (constraintType === CONSTRAINT_TYPES.MSO) {
       this.setCalculations(activity, activity.start_date, activity.end_date);
@@ -8306,24 +8042,6 @@ var BackwardPath = class extends generic_calculations_default {
       return;
     }
   }
-  /**
-   * Sets the latest start (LS) and latest finish (LF) times for a given activity in the internal calculations map.
-   *
-   * This function stores the LS and LF times, along with the activity's text, in the internal `calculations` map
-   * using the activity's ID as the key.
-   *
-   * @param {Object} activity - The activity object containing the details of the activity.
-   * @param {Date} ls - The latest start time for the activity.
-   * @param {Date} lf - The latest finish time for the activity.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activity is an object with id and text properties, and ls and lf are Date objects
-   * setCalculations(activity, new Date('2023-01-01'), new Date('2023-01-10'));
-   * // This will store the LS and LF times in the calculations map for the given activity.
-   *
-   * @throws {Error} If an error occurs during the calculation process.
-   */
   setCalculations(activity, ls, lf) {
     this.calculations.set(activity.id, {
       ls,
@@ -8331,28 +8049,6 @@ var BackwardPath = class extends generic_calculations_default {
       text: activity.text
     });
   }
-  /**
-    * Calculates the latest start (LS) and latest finish (LF) times for an activity based on its links with successors and the given constraint type.
-    *
-    * This function creates a new instance of the `LinksConstraintCalculator` class with the provided parameters and calls its `calculate` method
-    * to determine the LS and LF times for the activity.
-    *
-    * @param {Array<string|number>} linksWithSucessors - An array of links to successor activities.
-    * @param {Object} activityReference - The activity object for which to calculate LS and LF times.
-    * @param {string} constraintType - The constraint type of the activity.
-    * @returns {Object} An object containing the calculated latest start (LS) and latest finish (LF) times.
-    * @property {Date} ls - The calculated latest start time.
-    * @property {Date} lf - The calculated latest finish time.
-    *
-    * @example
-    * // Assuming linksWithSucessors is an array of link IDs, activityReference is an activity object,
-    * // and constraintType is a string representing the constraint type
-    * const result = calculateLfandLsFromLinks([1, 2, 3], activityReference, 'mso');
-    * console.log()
-  // { ls: Date, lf: Date }
-    *
-    * @throws {Error} If an error occurs during the calculation process.
-    */
   calculateLfandLsFromLinks(linksWithSucessors, activityReference, constraintType, parentsWithFullProgress, parentsThatImpactChildrens) {
     return new LinksConstraintCalculator_default({
       links: linksWithSucessors,
@@ -8365,23 +8061,6 @@ var BackwardPath = class extends generic_calculations_default {
       ganttInstance: this.gantt
     }).calculate();
   }
-  /**
-   * Recalculates the latest start (LS) and latest finish (LF) times for an activity based on its constraint type.
-   *
-   * This function fetches the activity's calendar, calculates the restriction based on the constraint type,
-   * updates the constraint map, and sets the new calculations for the activity.
-   *
-   * @param {Object} activity - The activity object containing the details of the activity.
-   * @param {string} constraintType - The constraint type of the activity.
-   * @returns {void} This function does not return a value.
-   *
-   * @example
-   * // Assuming activity is an object with calendar_id property, and constraintType is 'mso'
-   * recalculateInBaseRestriction(activity, 'mso');
-   * // This will recalculate the LS and LF times for the activity based on the constraint type and update the internal calculations.
-   *
-   * @throws {Error} If an error occurs during the calculation process, such as missing calendar data.
-   */
   recalculateInBaseRestriction(activity, constraintType) {
     try {
       const activityCalendar = this.gantt.getCalendar(activity.calendar_id);
@@ -9429,6 +9108,8 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "selection-toggle",
   "selection-replace",
   "visibility-set",
+  "filter-set",
+  "sort-set",
   "sir-sync",
   "activity-lookahead-sync",
   "persistence-acknowledge",
@@ -9436,6 +9117,16 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "ponderator-criterion-set",
   "status-criteria-set"
 ]);
+var PURE_VIEW_STATE_KINDS = /* @__PURE__ */ new Set([
+  "selection-toggle",
+  "selection-replace",
+  "visibility-set",
+  "filter-set",
+  "sort-set"
+]);
+function reappliesViewState(action) {
+  return !PURE_VIEW_STATE_KINDS.has(action.kind);
+}
 var NO_STRUCTURAL_EXEMPTIONS = /* @__PURE__ */ new Set();
 function editsOnlyNonSchedulingColumns(action) {
   if (action.kind === "inline-edit") {
@@ -9744,7 +9435,7 @@ function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
 }
 
 // src/dispatch/shared/change-set.ts
-function assembleChangeSet(adapter, args) {
+async function assembleChangeSet(adapter, args) {
   const allTouched = collectChangeSetIds(adapter, args);
   const before = new Map(args.beforeSnap);
   const captured = adapter.peekWriteCapture();
@@ -9753,7 +9444,16 @@ function assembleChangeSet(adapter, args) {
     mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
   }
   const beforeDiffEffects = args.sirDetection === "before-diff" ? detectSirAutoReject(before, adapter, allTouched) : [];
-  const activityChanges = buildActivityChanges(adapter, before, allTouched);
+  const correlativeBefore = buildCorrelativeBeforeMap(
+    args.correlativeShifts,
+    allTouched
+  );
+  const activityChanges = await buildActivityChanges(
+    adapter,
+    before,
+    allTouched,
+    correlativeBefore
+  );
   const effects = args.sirDetection === "after-diff" ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
   const warnings = args.warnings ?? [];
   return {
@@ -9761,12 +9461,20 @@ function assembleChangeSet(adapter, args) {
     activities: activityChanges,
     links: args.links ?? [],
     calendars: [],
-    // dispatch never mutates calendars
     trackingEvents: args.trackingEvents ?? [],
     ...effects.length > 0 ? { effects } : {},
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+function buildCorrelativeBeforeMap(shifts, touched) {
+  if (!shifts || shifts.length === 0) return void 0;
+  const correlativeBefore = /* @__PURE__ */ new Map();
+  for (const shift of shifts) {
+    correlativeBefore.set(shift.activityId, shift.before);
+    touched.add(shift.activityId);
+  }
+  return correlativeBefore;
+}
 function collectChangeSetIds(adapter, args) {
   const ids = /* @__PURE__ */ new Set();
   for (const id of args.touchedIds) ids.add(id);
@@ -9964,7 +9672,7 @@ async function dispatchInlineEdit(action, options, deps) {
     parsed2.raw
   );
   const touchedIds = collectTouchedIds(action.activityId, changes);
-  const beforeSnap = snapshotActivities(adapter, touchedIds);
+  const beforeSnap = await snapshotActivities(adapter, touchedIds);
   const beforeLinkLags = snapshotIncomingLinkLags(
     adapter,
     String(action.activityId)
@@ -10036,7 +9744,7 @@ async function dispatchInlineEdit(action, options, deps) {
   );
   return {
     ok: true,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds,
@@ -10146,7 +9854,10 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
   const { adapter, scheduler, sector, linkIdGen } = deps;
   scheduler.invalidateAllCaches();
   const { activityIds: affectedActivityIds, links: beforeLinks } = collectBatchContext(operations, adapter);
-  const beforeActivities = snapshotActivities(adapter, affectedActivityIds);
+  const beforeActivities = await snapshotActivities(
+    adapter,
+    affectedActivityIds
+  );
   const applied = applyBatchOperations(
     operations,
     adapter,
@@ -10189,7 +9900,7 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
       }
     ),
     __beforeLinks: stringKeyedLinkSnapshots(beforeLinks),
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source,
       beforeSnap: beforeActivities,
       touchedIds: affectedActivityIds,
@@ -10285,85 +9996,6 @@ var DISPATCH_TRACK_EVENT = {
   ACTIVITY_OUTDENT: "schedule_activity_outdent"
 };
 
-// src/internal/hierarchy/visual-order.ts
-var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-function getChildrenInVisualOrder(parentId, adapter) {
-  const children = collectChildrenSnapshots(parentId, adapter);
-  children.sort(compareActivitiesInVisualOrder);
-  return children.map((a) => String(a.id));
-}
-function iterateInVisualOrder(adapter) {
-  const result = [];
-  const visit = (activity) => {
-    result.push(activity);
-    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
-    for (const childId of childIds) {
-      const child = adapter.getActivity(childId);
-      if (child) visit(child);
-    }
-  };
-  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
-  for (const rootId of rootIds) {
-    const root = adapter.getActivity(rootId);
-    if (root) visit(root);
-  }
-  return result;
-}
-function findPreviousNonSelectedSibling(taskId, selected, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return null;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  const idx = siblings.findIndex((id) => String(id) === String(taskId));
-  if (idx <= 0) return null;
-  for (let i = idx - 1; i >= 0; i--) {
-    const candidateId = siblings[i];
-    if (candidateId === void 0) continue;
-    if (!setHas(selected, candidateId)) return candidateId;
-  }
-  return null;
-}
-function visualIndexInParent(taskId, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return -1;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  return siblings.findIndex((id) => String(id) === String(taskId));
-}
-function collectChildrenSnapshots(parentId, adapter) {
-  const key = String(parentId);
-  if (key === "0") {
-    return adapter.getAllActivities().filter((a) => a.parentId === null);
-  }
-  const childIds = adapter.getChildren(parentId);
-  const out = [];
-  for (const id of childIds) {
-    const snap = adapter.getActivity(id);
-    if (snap) out.push(snap);
-  }
-  return out;
-}
-function compareActivitiesInVisualOrder(a, b) {
-  const ac = correlativeIdOf(a);
-  const bc = correlativeIdOf(b);
-  if (ac !== bc) return ac - bc;
-  return String(a.id).localeCompare(String(b.id));
-}
-function correlativeIdOf(activity) {
-  const raw = activity.correlativeId;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
-}
-function parentKeyOf(activity) {
-  const parentId = activity.parentId;
-  if (parentId === null) return "0";
-  return parentId;
-}
-function setHas(set, id) {
-  if (set.has(id)) return true;
-  return set.has(String(id));
-}
-
 // src/internal/hierarchy/recompute-correlative-ids.ts
 function recomputeCorrelativeIds(adapter) {
   adapter.invalidateVisualOrderIds?.();
@@ -10796,7 +10428,7 @@ function computeFractionalCidAtIndex(adapter, parentKey, targetIndex, excludeId)
 }
 
 // src/dispatch/handlers/activity-create.ts
-function createActivityCore(action, deps, opts = {}) {
+async function createActivityCore(action, deps, opts = {}) {
   const { adapter, scheduler, sector, calendars, activityIdGen, uidGen } = deps;
   scheduler.invalidateAllCaches();
   const target = validateCreateTarget(action, adapter);
@@ -10837,7 +10469,7 @@ function createActivityCore(action, deps, opts = {}) {
   const initialTouched = /* @__PURE__ */ new Set([newId]);
   if (parent) initialTouched.add(parent.id);
   const parentWasLeaf = parent !== null && adapter.getChildren(parent.id).length === 0;
-  const beforeSnap = opts.skipBeforeSnap ? /* @__PURE__ */ new Map() : snapshotActivities(adapter, initialTouched);
+  const beforeSnap = opts.skipBeforeSnap ? /* @__PURE__ */ new Map() : await snapshotActivities(adapter, initialTouched);
   adapter.addActivity(newActivity);
   applyParentMutations(
     action,
@@ -10957,7 +10589,7 @@ function recomputeAndFoldCorrelatives(adapter, newId, beforeSnap, initialTouched
     initialTouched
   );
 }
-function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay) {
+async function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPerDay) {
   const { newId, newActivity, beforeSnap, initialTouched } = coreResult;
   const trackingEvent = {
     name: DISPATCH_TRACK_EVENT.ACTIVITY_CREATION,
@@ -10979,7 +10611,7 @@ function buildCreateChangeSet(adapter, action, coreResult, scheduledIds, hoursPe
 }
 async function dispatchActivityCreate(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
-  const core = createActivityCore(action, deps);
+  const core = await createActivityCore(action, deps);
   if (!core.ok) return core;
   const { newId } = core;
   const createdAutoScheduling = core.newActivity.autoScheduling;
@@ -11005,7 +10637,7 @@ async function dispatchActivityCreate(action, options, deps) {
     adapter.setActivityField(newId, "autoScheduling", createdAutoScheduling);
   }
   const { scheduledIds } = scheduleOutcome;
-  const changeset = buildCreateChangeSet(
+  const changeset = await buildCreateChangeSet(
     adapter,
     action,
     core,
@@ -11055,7 +10687,7 @@ async function dispatchActivityPaste(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
   const rootDest = resolvePasteRootDestination(action.destination, adapter);
   if (!rootDest.ok) return rootDest;
-  const beforeSnap = snapshotActivities(adapter, /* @__PURE__ */ new Set());
+  const beforeSnap = await snapshotActivities(adapter, /* @__PURE__ */ new Set());
   const touched = /* @__PURE__ */ new Set();
   const originalToNew = /* @__PURE__ */ new Map();
   const createdIds = [];
@@ -11076,7 +10708,7 @@ async function dispatchActivityPaste(action, options, deps) {
         afterSiblingId = prevRootId;
       }
     }
-    const core = createActivityCore(
+    const core = await createActivityCore(
       {
         parentId,
         afterSiblingId,
@@ -11087,16 +10719,8 @@ async function dispatchActivityPaste(action, options, deps) {
       },
       deps,
       {
-        // Saltamos el recompute por-create: corre UNA vez tras el loop (abajo).
         skipCorrelativeRecompute: true,
-        // Saltamos el snapshot per-create: el paste ya capturó `beforeSnap` del
-        // árbol completo antes del loop (O(N²) de clones puros si no).
         skipBeforeSnap: true,
-        // custom_id (paridad legacy): TODAS las pegadas derivan del ancla de
-        // pegado. Los roots ya lo logran vía `afterSiblingId`; los HIJOS
-        // (mappedParent) no tienen sibling anchor → les pasamos el ancla como
-        // `customIdReferenceId`, y preservamos el custom_id de su parent pegado
-        // (que si no, `buildParentMutations` limpiaría al adjuntar el hijo).
         ...mappedParent !== void 0 ? {
           customIdReferenceId: action.referenceActivityId,
           preserveParentCustomId: true
@@ -11140,9 +10764,6 @@ async function dispatchActivityPaste(action, options, deps) {
       source: newSource,
       target: newTarget,
       type: link.type,
-      // El clipboard trae `lag` en DÍAS (getLink/getAllLinks → lagHoursToDays);
-      // el motor lo almacena en HORAS LABORALES. Convertir acá, igual que
-      // `duration` arriba y que `link-create`/`link-update` — el borde de entrada.
       lag: lagDaysToHours(link.lag, sector.hoursPerDay)
     };
     const res = applyLinkOperation(op, {
@@ -11177,7 +10798,7 @@ async function dispatchActivityPaste(action, options, deps) {
   );
   return {
     ok: true,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
@@ -11389,6 +11010,7 @@ function buildParentNewActivitiesCleanup(input) {
 }
 
 // src/dispatch/handlers/activity-delete.ts
+var DELETE_YIELD_EVERY_N = 200;
 async function dispatchActivityDelete(action, options, deps) {
   const { adapter, scheduler, customIdTracker, sector } = deps;
   scheduler.invalidateAllCaches();
@@ -11412,14 +11034,17 @@ async function dispatchActivityDelete(action, options, deps) {
     if (!toDelete.has(parentKey)) parentsToCheck.add(parentKey);
   }
   const touchedIds = /* @__PURE__ */ new Set([...toDelete, ...parentsToCheck]);
-  const beforeSnap = snapshotActivities(adapter, touchedIds);
+  const beforeSnap = await snapshotActivities(adapter, touchedIds);
   const beforeLinks = /* @__PURE__ */ new Map();
   for (const linkId of incidentLinkIds) {
     const l = adapter.getLink(linkId);
     if (l) beforeLinks.set(linkId, { ...l });
   }
   const newActivitiesToDelete = /* @__PURE__ */ new Set();
+  let inspected = 0;
   for (const id of toDelete) {
+    inspected += 1;
+    if (inspected % DELETE_YIELD_EVERY_N === 0) await yieldToBrowser();
     const a = adapter.getActivity(id);
     if (!a) continue;
     const parent = isRootParent(a.parentId) ? null : adapter.getActivity(String(a.parentId));
@@ -11436,7 +11061,10 @@ async function dispatchActivityDelete(action, options, deps) {
     adapter.removeLink(linkId);
   }
   const viewStateChanges = captureDeletedViewState(adapter, toDelete);
+  let removed = 0;
   for (const id of toDelete) {
+    removed += 1;
+    if (removed % DELETE_YIELD_EVERY_N === 0) await yieldToBrowser();
     adapter.removeActivity(id);
   }
   for (const parentId of parentsToCheck) {
@@ -11476,15 +11104,6 @@ async function dispatchActivityDelete(action, options, deps) {
     recomputeRollupCascadesForParent(parentId, adapter);
   }
   const correlativeShifts = recomputeCorrelativeIds(adapter);
-  for (const shift of correlativeShifts) {
-    touchedIds.add(shift.activityId);
-    if (beforeSnap.has(shift.activityId)) continue;
-    const liveActivity = adapter.getActivity(shift.activityId);
-    if (!liveActivity) continue;
-    const beforeImage = structuredCloneActivity(liveActivity);
-    if (shift.before !== void 0) beforeImage.correlativeId = shift.before;
-    beforeSnap.set(shift.activityId, beforeImage);
-  }
   const { scheduledIds } = await runPostMutation(
     {
       adapter,
@@ -11517,7 +11136,7 @@ async function dispatchActivityDelete(action, options, deps) {
     const snap = beforeSnap.get(String(id));
     if (snap) deletedRowsSnap.set(String(id), snap);
   }
-  const changes = assembleChangeSet(adapter, {
+  const changes = await assembleChangeSet(adapter, {
     source: action,
     beforeSnap,
     touchedIds,
@@ -11525,7 +11144,8 @@ async function dispatchActivityDelete(action, options, deps) {
     sirDetection: "after-diff",
     links: buildLinkDeletions(beforeLinks),
     trackingEvents: [trackingEvent],
-    hoursPerDay: sector.hoursPerDay
+    hoursPerDay: sector.hoursPerDay,
+    correlativeShifts
   });
   return {
     ok: true,
@@ -11565,8 +11185,6 @@ function buildLinkDeletions(beforeLinks) {
         source: { before: String(before.source), after: void 0 },
         target: { before: String(before.target), after: void 0 },
         type: { before: before.type, after: void 0 },
-        // Engine stores lag in WORKING HOURS — ChangeSet now emits HOURS too.
-        // `toPublicChangeSet` at the facade boundary converts to days (default).
         lag: { before: Number(before.lag), after: void 0 }
       },
       after: null
@@ -11655,7 +11273,7 @@ async function dispatchActivityMove(action, options, deps) {
   } else {
     if (oldParentKey !== ROOT_PARENT_ID) touched.add(oldParentKey);
   }
-  const beforeSnap = snapshotActivities(adapter, touched);
+  const beforeSnap = await snapshotActivities(adapter, touched);
   if (parentChanged) {
     adapter.setActivityField(
       action.activityId,
@@ -11685,8 +11303,6 @@ async function dispatchActivityMove(action, options, deps) {
           newChildId: action.activityId,
           getParent: (id) => adapter.getActivity(id) ?? null,
           isCurrentlyLeaf: wasLeaf,
-          // Move reparents an EXISTING child — legacy never re-stamps the new
-          // parent's progress (it keeps its pre-move leaf value). See JUN-23.
           promotionSource: "reparent"
         });
         if (promotion) {
@@ -11795,7 +11411,7 @@ async function dispatchActivityMove(action, options, deps) {
   }
   return {
     ok: true,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
@@ -11857,7 +11473,7 @@ async function dispatchActivityIndent(action, options, deps) {
     touched.add(targetParentId);
     if (oldParentId !== ROOT_PARENT_ID) touched.add(oldParentId);
   }
-  const beforeSnap = snapshotActivities(adapter, touched);
+  const beforeSnap = await snapshotActivities(adapter, touched);
   for (const { activityId, newParentId } of moves) {
     adapter.setActivityField(activityId, ACTIVITY_PROPERTY.PARENT, newParentId);
     adapter.setActivityField(
@@ -11881,8 +11497,6 @@ async function dispatchActivityIndent(action, options, deps) {
       newChildId: activityId,
       getParent: (id) => adapter.getActivity(id) ?? null,
       isCurrentlyLeaf: wasLeaf,
-      // Indent reparents an EXISTING child — legacy never re-stamps the new
-      // parent's progress (it keeps its pre-indent leaf value). See JUN-23.
       promotionSource: "reparent"
     });
     if (promotion) {
@@ -11949,33 +11563,8 @@ async function dispatchActivityIndent(action, options, deps) {
     },
     {
       action,
-      // A pure indent (reparent) does NOT auto-reschedule dates in legacy:
-      // `actions.indent` runs purely through `gantt.moveTask`, firing only
-      // `onBeforeTaskMove`/`onAfterTaskMove` — never `autoSchedule()` /
-      // `onAfterAutoSchedule`. So the moved child + its downstream chain KEEP
-      // their pre-indent dates; only the new parent's bounds re-roll (via
-      // DHTMLX `_update_parents` in the move's batchUpdate — done unconditionally
-      // by `updateParentBoundsFromChildren` below). The core previously passed
-      // `{}` here, running a full ASAP/ALAP reflow that pulled the moved child +
-      // chain as-early-as-possible — diverging from the oracle (MORNING_QUEUE.md
-      // — JUN-11 corr20 stays 2024-05-07 stale, core moved it to 04-30; JUN-16(B)
-      // corr33 stays 2026-10-21 stale, core pulled it to 09-16). `null` suppresses
-      // the date cascade entirely, completing the outdent mirror (outdent's `{}`
-      // was always a no-op because its moved child keeps its links/position; a
-      // childless leaf + reparent of an EXISTING activity is never the trigger
-      // of an autoSchedule). A SUBSEQUENT date/constraint/link edit still
-      // cascades normally (its own handler passes a non-null trigger).
       autoscheduleFrom: null,
       recomputeParentsFrom: succeededIds,
-      // A pure indent re-rolls the new parent's start/end/duration but legacy
-      // leaves `for_disable_milestone_duration` STALE at the pre-indent value —
-      // the milestone-promotion branch (`adjustParentMilestone`) only fires for a
-      // 0-duration milestone, never a task → project promotion (MORNING_QUEUE.md
-      // — JUN-18 / JUN-11). A later scheduling recalc that re-rolls these parents
-      // re-derives the mirror = duration — that is how the oracle's mirror is
-      // FRESH whenever an edit follows the indent (MORNING_QUEUE.md — JUN-19).
-      // `resolveDerivedPasses` skips the ancestor stamp for activity-indent.
-      // activity-indent is a structural reparent: leaves EP and CP stale.
       now: deps.now,
       options
     }
@@ -12007,7 +11596,7 @@ async function dispatchActivityIndent(action, options, deps) {
         reason: failure.reason
       } : { activityId: String(activityId), ok: true };
     }),
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
@@ -12105,7 +11694,7 @@ async function dispatchActivityOutdent(action, options, deps) {
     if (grandparentKey !== ROOT_PARENT_ID) touched.add(String(grandparentKey));
     oldParents.add(oldParentKey);
   }
-  const beforeSnap = snapshotActivities(adapter, touched);
+  const beforeSnap = await snapshotActivities(adapter, touched);
   for (const plan of planned) {
     adapter.setActivityField(
       plan.activityId,
@@ -12192,12 +11781,9 @@ async function dispatchActivityOutdent(action, options, deps) {
       defaultBaseCalendarId: deps.defaultBaseCalendarId
     },
     {
-      // Empty-batch gate: nothing moved → no autoscheduler pass (the
-      // unconditional parent-bounds rollup still runs).
       action,
       autoscheduleFrom: succeededIds.length > 0 ? "roots" : null,
       recomputeParentsFrom: succeededIds,
-      // activity-outdent is a structural reparent: leaves EP and CP stale.
       now: deps.now,
       options
     }
@@ -12227,7 +11813,7 @@ async function dispatchActivityOutdent(action, options, deps) {
         reason: failure.reason
       } : { activityId: String(activityId), ok: true };
     }),
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds: touched,
@@ -12264,7 +11850,7 @@ async function dispatchActivitySetProgress(action, options, deps) {
     action.newValue
   );
   const touchedIds = collectTouchedIds(action.activityId, changes);
-  const beforeSnap = snapshotActivities(adapter, touchedIds);
+  const beforeSnap = await snapshotActivities(adapter, touchedIds);
   applyFieldChanges(adapter, action.activityId, changes);
   runPostProcessorsOnAdapter(
     action.activityId,
@@ -12280,7 +11866,6 @@ async function dispatchActivitySetProgress(action, options, deps) {
     },
     {
       action,
-      // Pipeline gate: only schedule when the transform asked for it.
       autoscheduleFrom: changes.needsAutoSchedule ? action.activityId : null,
       recomputeParentsFrom: [],
       collectDirty: (sids) => collectDirtyForInlineEdit(action.activityId, touchedIds, sids),
@@ -12294,7 +11879,7 @@ async function dispatchActivitySetProgress(action, options, deps) {
   }));
   return {
     ok: true,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds,
@@ -12323,9 +11908,10 @@ async function dispatchDatesBatch(action, options, deps) {
     mergeBeforeSnapshots(beforeSnap, editTouched, deps);
     for (const id of editTouched) touchedIds.add(id);
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
-    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+    const preEditSnapshot = snapshotSingleActivity(
+      adapter,
       String(edit.activityId)
-    ) ?? null;
+    );
     applyFieldChanges(adapter, edit.activityId, outcome.changes);
     runPostProcessorsOnAdapter(
       edit.activityId,
@@ -12367,7 +11953,7 @@ async function dispatchDatesBatch(action, options, deps) {
   return {
     ok: true,
     verdicts,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds,
@@ -12448,8 +12034,11 @@ function mergeBeforeSnapshots(beforeSnap, ids, deps) {
     if (!beforeSnap.has(id)) missing.add(id);
   }
   if (missing.size === 0) return;
-  for (const [id, snap] of snapshotActivities(deps.adapter, missing)) {
-    beforeSnap.set(id, snap);
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
+    }
   }
 }
 
@@ -12489,9 +12078,10 @@ async function dispatchBulkEdit(action, options, deps) {
       explicitDateEditActivities.add(String(edit.activityId));
     }
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
-    const preEditSnapshot = snapshotActivities(adapter, /* @__PURE__ */ new Set([String(edit.activityId)])).get(
+    const preEditSnapshot = snapshotSingleActivity(
+      adapter,
       String(edit.activityId)
-    ) ?? null;
+    );
     const customIdBeforeApply = readLiveCustomId(edit, deps);
     const changes = outcome.changes;
     applyFieldChanges(adapter, edit.activityId, changes);
@@ -12555,14 +12145,11 @@ async function dispatchBulkEdit(action, options, deps) {
   return {
     ok: true,
     verdicts,
-    changes: assembleChangeSet(adapter, {
+    changes: await assembleChangeSet(adapter, {
       source: action,
       beforeSnap,
       touchedIds,
       scheduledIds,
-      // Los dependientes que mueve el autoscheduler no están en beforeSnap;
-      // sin su before-image el diff los marca FALSE-CREATED y el undo los
-      // borra (fix 4bbccbc de inline-edit).
       sirDetection: "before-diff",
       links: linkChanges,
       trackingEvents,
@@ -12689,11 +12276,11 @@ function mergeBeforeSnapshots2(beforeSnap, ids, deps) {
     if (!beforeSnap.has(candidateId)) missing.add(candidateId);
   }
   if (missing.size === 0) return;
-  for (const [snappedId, snapshot] of snapshotActivities(
-    deps.adapter,
-    missing
-  )) {
-    beforeSnap.set(snappedId, snapshot);
+  for (const missingId of missing) {
+    const liveActivity = deps.adapter.getActivity(missingId);
+    if (liveActivity) {
+      beforeSnap.set(missingId, structuredCloneActivity(liveActivity));
+    }
   }
 }
 
@@ -13117,8 +12704,8 @@ function activeBaselineSignature(deps) {
     })
   );
 }
-function dispatchBaselineApply(action, deps) {
-  const beforeSnap = snapshotActivities(
+async function dispatchBaselineApply(action, deps) {
+  const beforeSnap = await snapshotActivities(
     deps.adapter,
     new Set(deps.adapter.getAllIds())
   );
@@ -13138,7 +12725,7 @@ function dispatchBaselineApply(action, deps) {
   }
   return {
     ok: true,
-    changes: assembleChangeSet(deps.adapter, {
+    changes: await assembleChangeSet(deps.adapter, {
       source: action,
       beforeSnap,
       touchedIds: changedIds,
@@ -13155,15 +12742,15 @@ function assertValidCriterion(value) {
     `ponderator-criterion-set: invalid criterion "${String(value)}"`
   );
 }
-function dispatchPonderatorCriterionSet(action, deps) {
+async function dispatchPonderatorCriterionSet(action, deps) {
   assertValidCriterion(action.criterion);
   const allIds = new Set(deps.adapter.getAllIds());
-  const beforeSnap = snapshotActivities(deps.adapter, allIds);
+  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
   recomputeBaselineWeightedFields(deps, action.criterion);
   deps.sector.activityCreter = action.criterion;
   return {
     ok: true,
-    changes: assembleChangeSet(deps.adapter, {
+    changes: await assembleChangeSet(deps.adapter, {
       source: action,
       beforeSnap,
       touchedIds: allIds,
@@ -13174,15 +12761,15 @@ function dispatchPonderatorCriterionSet(action, deps) {
 }
 
 // src/dispatch/handlers/status-criteria-set.ts
-function dispatchStatusCriteriaSet(action, deps) {
+async function dispatchStatusCriteriaSet(action, deps) {
   const resolved = resolveStatusCriteria(action.criteria);
   const allIds = new Set(deps.adapter.getAllIds());
-  const beforeSnap = snapshotActivities(deps.adapter, allIds);
+  const beforeSnap = await snapshotActivities(deps.adapter, allIds);
   const changedIds = applyStatusPass(deps.adapter, resolved);
   deps.sector.statusCriteria = resolved;
   return {
     ok: true,
-    changes: assembleChangeSet(deps.adapter, {
+    changes: await assembleChangeSet(deps.adapter, {
       source: action,
       beforeSnap,
       touchedIds: changedIds,
@@ -13248,6 +12835,15 @@ async function dispatch(action, options, deps) {
   if (action.kind === "visibility-set") {
     return dispatchVisibilitySet(action, selectionDeps(deps));
   }
+  if (action.kind === "filter-set") {
+    return dispatchFilterSet(action, {
+      adapter: deps.adapter,
+      hoursPerDay: deps.sector.hoursPerDay
+    });
+  }
+  if (action.kind === "sort-set") {
+    return dispatchSortSet(action, { adapter: deps.adapter });
+  }
   if (action.kind === "sir-sync") {
     return dispatchSirSync(action, deps);
   }
@@ -15770,9 +15366,7 @@ var defaultLocale = {
 function createGanttShim(options = {}) {
   const userConfig = options.config || {};
   const shim = {
-    // ------ Config ------
     config: Object.assign({
-      // Defaults críticos para calendar
       duration_unit: "hour",
       duration_step: 1,
       work_time: false,
@@ -15783,16 +15377,13 @@ function createGanttShim(options = {}) {
       resource_property: "resource_id",
       resource_calendars: {},
       dynamic_resource_calendars: false,
-      // Config date module
       start_on_monday: true,
       server_utc: true,
       csp: "auto",
       show_errors: false
     }, userConfig),
-    // ------ Locale + templates ------
     locale: options.locale || defaultLocale,
     templates: options.templates || {},
-    // ------ Task resolver (opcional) ------
     getTask: options.getTask || function(id) {
       return null;
     },
@@ -15802,11 +15393,9 @@ function createGanttShim(options = {}) {
     isSummaryTask: options.isSummaryTask || function(task) {
       return false;
     },
-    // ------ State (mínimo) ------
     getState: function() {
       return { group_mode: false };
     },
-    // ------ Eventable (no-ops por defecto) ------
     callEvent: function(name, args) {
       const handler = options.onEvent;
       if (handler) handler(name, args);
@@ -15820,7 +15409,6 @@ function createGanttShim(options = {}) {
     },
     detachEvent: function() {
     },
-    // ------ Utils expuestas en gantt2 ------
     defined,
     mixin,
     copy,
@@ -15830,7 +15418,6 @@ function createGanttShim(options = {}) {
         else if (options.silent !== true) console.error("[calendar]", msg);
       }
     },
-    // ------ $services / $ui — stubs minimales para evitar cracks ------
     $services: { getService: function() {
       return null;
     } },
@@ -15851,7 +15438,6 @@ function createGanttShim(options = {}) {
 function createCalendar(options = {}) {
   const shim = createGanttShim(options);
   return {
-    // ------ Gestión de calendarios ------
     addCalendar: function(c) {
       return shim.addCalendar(c);
     },
@@ -15873,7 +15459,6 @@ function createCalendar(options = {}) {
     getResourceCalendar: function(r) {
       return shim.getResourceCalendar(r);
     },
-    // ------ Cálculo (también disponible en cada Calendar instance) ------
     setWorkTime: function(c) {
       return shim.setWorkTime(c);
     },
@@ -15895,7 +15480,6 @@ function createCalendar(options = {}) {
     calculateEndDate: function() {
       return shim.calculateEndDate.apply(shim, arguments);
     },
-    // ------ Para inspección/debug ------
     _internals: shim
   };
 }
@@ -15923,16 +15507,11 @@ function normalizeWorktimeHours(hours) {
   return [`${first}:00-${last + 1}:00`];
 }
 var DEFAULT_WORKTIME = {
-  // 08:00..16:00 UTC, Mon..Fri. Matches the prior generic fallback used by
-  // synthetic fixtures and CPM nodes whose calendar id is genuinely unknown.
   hours: ["8:00-16:00"],
   days: [false, true, true, true, true, true, false]
 };
 var CATALOG_ONLY_CALENDAR_ID = "__main_global__";
 var CATALOG_ONLY_WORKTIME = {
-  // Native MAIN/DHTMLX global calendar. A calendar present in the selector but
-  // lacking usable shifts is not registered by MAIN, so its date arithmetic
-  // falls through to this split-day global calendar.
   hours: ["8:00-12:00", "13:00-17:00"],
   days: [false, true, true, true, true, true, false]
 };
@@ -16124,7 +15703,6 @@ var WriteCapture = class {
   end() {
     this._journal = null;
   }
-  /** Field write on an activity — pre-mutation clone on first write per id. */
   note(key, current) {
     const journal = this._journal;
     if (!journal) return;
@@ -16152,13 +15730,11 @@ var WriteCapture = class {
       before: cloneLink(current)
     });
   }
-  /** Pre-sweep correlative_id of an activity the renumbering shifted (first-wins). */
   noteCorrelativeBefore(activityId, before) {
     const journal = this._journal;
     if (!journal || journal.correlativeBefore.has(activityId)) return;
     journal.correlativeBefore.set(activityId, before);
   }
-  /** Pre-applyResults clone of an activity the autoscheduler will move (first-wins). */
   noteScheduledBefore(activityId, current) {
     const journal = this._journal;
     if (!journal) return;
@@ -16171,7 +15747,6 @@ var WriteCapture = class {
     }
     journal.dirty.add(activityId);
   }
-  /** Field write on a link — pre-mutation clone on first write per link id. */
   noteLinkField(linkId, current) {
     const journal = this._journal;
     if (!journal || journal.linkFieldCaptured.has(linkId)) return;
@@ -16189,17 +15764,11 @@ function cloneLink(link) {
 
 // src/internal/state/calendar-calculator.ts
 var CalendarCalculator = class {
-  // In-dispatch calendar API memoization. Lifetime = one scheduler run.
   _cache = {
     closestWorkTime: /* @__PURE__ */ new Map(),
     endDate: /* @__PURE__ */ new Map(),
     duration: /* @__PURE__ */ new Map()
   };
-  // Single owner of the calendar subsystem. The calc resolves calendars (incl.
-  // the `-base` ones and the default fallback) through the reader — one resolver
-  // for the whole calendar surface instead of a separate Map + default field.
-  /** Resolver for ANY calendar incl. the `-base` ones — also consumed by the
-   * column pipelines via `pipeline-context`. */
   reader;
   constructor(setup) {
     this.reader = setup.reader;
@@ -16242,11 +15811,6 @@ var CalendarCalculator = class {
       )
     );
   }
-  /**
-   * Clears the in-dispatch calendar API memoization. Call at the start of
-   * every scheduler run (calendars are immutable within a dispatch but may
-   * change across dispatches).
-   */
   clearCache() {
     this._cache.closestWorkTime.clear();
     this._cache.endDate.clear();
@@ -16279,16 +15843,7 @@ var HierarchyIndex = class {
   activities;
   _childrenByParent = /* @__PURE__ */ new Map();
   _roots = [];
-  /**
-   * When true, `_childrenByParent` is stale (a `parent` write happened) and is
-   * lazily rebuilt on the next `getChildren`. A bulk reparent (K rows) marks
-   * dirty K times but pays ONE rebuild on the next read instead of K — turning
-   * bulk indent/outdent from O(K·N) into O(K+N). Only `getChildren` reads this
-   * index; `getParent`/`getParentId`/`isChildOf` read `activities` directly and
-   * are always fresh, so they don't consult the flag. See PERFORMANCE.md §A3.
-   */
   _dirty = false;
-  /** Mark the children index stale; the next `getChildren` rebuilds it once. */
   markDirty() {
     this._dirty = true;
   }
@@ -16332,11 +15887,6 @@ var HierarchyIndex = class {
   getParentId(id) {
     return this.activities.get(id)?.parentId ?? null;
   }
-  /**
-   * Incremental O(1) insert for a freshly added activity (create/paste).
-   * The id is new, so no rebuild is needed — reparenting goes through
-   * `rebuild()` instead.
-   */
   addChild(parentId, id) {
     if (this._dirty) return;
     if (isRootParent(parentId)) {
@@ -16348,7 +15898,6 @@ var HierarchyIndex = class {
     if (arr) arr.push(id);
     else this._childrenByParent.set(key, [id]);
   }
-  /** Full rebuild from the activity store. */
   rebuild() {
     this._childrenByParent.clear();
     this._roots = [];
@@ -16381,12 +15930,29 @@ var HierarchyIndex = class {
 var ViewStateStore = class {
   checkedSet = /* @__PURE__ */ new Set();
   hiddenSet = /* @__PURE__ */ new Set();
+  activeFilter = null;
+  activeOrder = null;
   isChecked(activityId) {
     return this.checkedSet.has(activityId);
   }
   isVisible(activityId) {
     return !this.hiddenSet.has(activityId);
   }
+  hiddenIds() {
+    return [...this.hiddenSet];
+  }
+  getActiveFilter() {
+    return this.activeFilter;
+  }
+  setActiveFilter(nextFilter) {
+    this.activeFilter = nextFilter;
+  }
+  getActiveOrder() {
+    return this.activeOrder;
+  }
+  setActiveOrder(nextOrder) {
+    this.activeOrder = nextOrder;
+  }
   checkedIds() {
     return [...this.checkedSet];
   }
@@ -16412,58 +15978,49 @@ var ViewStateStore = class {
   hydrate(seed2) {
     this.checkedSet = new Set(seed2.checkedIds ?? []);
     this.hiddenSet = new Set(seed2.hiddenIds ?? []);
+    this.activeFilter = null;
+    this.activeOrder = null;
   }
   snapshot() {
     return {
       checked: new Set(this.checkedSet),
-      hidden: new Set(this.hiddenSet)
+      hidden: new Set(this.hiddenSet),
+      activeFilter: this.activeFilter,
+      activeOrder: this.activeOrder
     };
   }
   restore(snapshot) {
     this.checkedSet = new Set(snapshot.checked);
     this.hiddenSet = new Set(snapshot.hidden);
+    this.activeFilter = snapshot.activeFilter;
+    this.activeOrder = snapshot.activeOrder;
   }
 };
 
 // src/internal/state/schedule-state.ts
 var ScheduleState = class {
-  // Private so every mutation routes through setActivityField/addActivity/…
-  // (the only path that feeds the write-capture → ChangeSet). External readers
-  // use the AutoSchedulerPort read methods (getActivity / getAllActivities / …).
   _activities = /* @__PURE__ */ new Map();
-  // Transient gesture state: the start_date an activity had at its last
-  // duration edit / drag. Read only by the no-op constraint revert to decide
-  // whether a soft constraint repositioned the activity. Never persisted,
-  // never in the ChangeSet — not domain data on CoreActivity.
   _lastStartDate = /* @__PURE__ */ new Map();
-  // Transient gesture state: what a leaf looked like right before it gained its
-  // first child and became a summary. Read by the demotion to give the activity
-  // its own values back instead of the aggregate its children left behind. Not
-  // persisted and not in the ChangeSet: it only makes sense inside the session
-  // that performed the promotion. Kept (not consumed) so undo/redo of a
-  // demotion restores identically every time.
   _promotionSnapshot = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
-  // Parent → children index. Assigned in the constructor (needs the
-  // activities Map reference). See `HierarchyIndex`.
   _hierarchy;
+  _buildOrderComparator;
   _cache = {
     ids: null,
-    visualOrderIds: null
+    visualOrderIds: null,
+    orderComparator: null
   };
-  // Per-dispatch write journal. See `WriteCapture` / `ActivityWriteCapture`.
   _writeCapture = new WriteCapture();
   _viewState = new ViewStateStore();
   _viewStateBefore = null;
   _lastStartDateBefore = null;
   _promotionSnapshotBefore = null;
-  // Calendar arithmetic + in-dispatch memoization. Assigned in the
-  // constructor once the calendar reader is built. See `CalendarCalculator`.
   _calendar;
   _flags;
-  constructor(snapshot) {
+  constructor(snapshot, buildOrderComparator = () => null) {
+    this._buildOrderComparator = buildOrderComparator;
     for (const activity of snapshot.activities) {
       this._activities.set(activity.id, activity);
     }
@@ -16478,22 +16035,12 @@ var ScheduleState = class {
     this._hierarchy = new HierarchyIndex(this._activities);
     this._hierarchy.rebuild();
   }
-  // -- AutoSchedulerPort: reads ------------------------------------------------
-  /**
-   * Materializes every alive activity. O(N) allocation.
-   * AVOID per-frame / per-dispatch consumers — prefer `forEachActivity` /
-   * `getAllIds` when only ids or fast field reads are needed.
-   */
   getAllActivities() {
     return Array.from(this._activities.values());
   }
   getAllLinks() {
     return Array.from(this._links.values());
   }
-  /**
-   * Read-only snapshot of every alive activity id. Cached and invalidated
-   * lazily on structural mutations (add/remove/parent change).
-   */
   getAllIds() {
     if (this._cache.ids) return this._cache.ids;
     this._cache.ids = Array.from(this._activities.keys());
@@ -16502,14 +16049,6 @@ var ScheduleState = class {
   activityCount() {
     return this._activities.size;
   }
-  /**
-   * Every alive activity id in canonical DFS visual order (pre-order from
-   * roots, siblings by `correlative_id` ASC — `iterateInVisualOrder`).
-   * Cached like `getAllIds`; invalidated on add/remove, on `parent` /
-   * `correlative_id` writes, and by `recomputeCorrelativeIds` (the only
-   * order chokepoint, which mutates `correlative_id` directly on the
-   * snapshots without going through `setActivityField`).
-   */
   getVisualOrderIds() {
     if (this._cache.visualOrderIds) return this._cache.visualOrderIds;
     this._cache.visualOrderIds = iterateInVisualOrder(this).map(
@@ -16517,14 +16056,9 @@ var ScheduleState = class {
     );
     return this._cache.visualOrderIds;
   }
-  /** Drops the memoized visual order. See `getVisualOrderIds`. */
   invalidateVisualOrderIds() {
     this._cache.visualOrderIds = null;
   }
-  /**
-   * Iterates every alive activity without materializing intermediate arrays.
-   * Use in hot paths that today call `getAllActivities()` only to walk it.
-   */
   forEachActivity(visit) {
     for (const [id, activity] of this._activities) {
       visit(activity, id);
@@ -16577,6 +16111,9 @@ var ScheduleState = class {
   checkedIds() {
     return this._viewState.checkedIds();
   }
+  hiddenIds() {
+    return this._viewState.hiddenIds();
+  }
   setChecked(activityId, nextChecked) {
     this._captureViewStateOnce();
     return this._viewState.setChecked(String(activityId), nextChecked);
@@ -16585,8 +16122,54 @@ var ScheduleState = class {
     this._captureViewStateOnce();
     return this._viewState.setVisible(String(activityId), nextVisible);
   }
+  getActiveFilter() {
+    return this._viewState.getActiveFilter();
+  }
+  setActiveFilter(nextFilter) {
+    this._captureViewStateOnce();
+    this._viewState.setActiveFilter(nextFilter);
+  }
+  getActiveOrder() {
+    return this._viewState.getActiveOrder();
+  }
+  setActiveOrder(nextOrder) {
+    this._captureViewStateOnce();
+    this._viewState.setActiveOrder(nextOrder);
+    this.invalidateDerivedOrder();
+  }
+  /**
+   * Rebuild-on-demand, memoized: at most one build per invalidation, never one
+   * per comparison. getChildrenInVisualOrder asks for this once and then sorts a
+   * whole sibling group with it, and collectBranchOrder walks every branch, so a
+   * build per read would be thousands per dispatch.
+   *
+   * The factory reads hoursPerDay and the collation locale at build time, so a
+   * rebuilt comparator always reflects the current context — that is what keeps
+   * ordering and filtering from seeing two different hoursPerDay.
+   */
+  getOrderComparator() {
+    const activeOrder = this._viewState.getActiveOrder();
+    if (activeOrder === null) {
+      this._cache.orderComparator = null;
+      return null;
+    }
+    if (this._cache.orderComparator) return this._cache.orderComparator;
+    this._cache.orderComparator = this._buildOrderComparator(activeOrder);
+    return this._cache.orderComparator;
+  }
+  /**
+   * Both order caches, always together. The comparator decides the sequence, so
+   * a rebuilt comparator with a surviving sequence would paint the old order.
+   * invalidateVisualOrderIds stays separate on purpose: a structural change
+   * moves rows without touching the rules, so the comparator is still valid.
+   */
+  invalidateDerivedOrder() {
+    this._cache.orderComparator = null;
+    this._cache.visualOrderIds = null;
+  }
   hydrateViewState(seed2) {
     this._viewState.hydrate(seed2);
+    this.invalidateDerivedOrder();
   }
   _captureViewStateOnce() {
     if (this._writeCapture.peek() === null) return;
@@ -16600,7 +16183,6 @@ var ScheduleState = class {
   getIncomingLinkIds(activityId) {
     return this._incoming.get(String(activityId)) ?? EMPTY_LINK_IDS;
   }
-  // -- AutoSchedulerPort: hierarchy --------------------------------------------
   getChildren(parentId) {
     return this._hierarchy.getChildren(parentId);
   }
@@ -16616,7 +16198,6 @@ var ScheduleState = class {
   getRootIds() {
     return this._hierarchy.getRootIds();
   }
-  // -- AutoSchedulerPort: calendar (snapshot-aware, M-F 08-16 UTC fallback) ---
   getClosestWorkTime(params) {
     return this._calendar.getClosestWorkTime(params);
   }
@@ -16626,66 +16207,44 @@ var ScheduleState = class {
   calculateDuration(params) {
     return this._calendar.calculateDuration(params);
   }
-  /**
-   * Clears the in-dispatch calendar API memoization. Call at the start of
-   * every scheduler run (calendars are immutable within a dispatch but may
-   * change across dispatches).
-   */
   clearCalendarCache() {
     this._calendar.clearCache();
   }
-  // Calendar resolver exposed for external consumers (initial-passes'
-  // expected_progress, adjust-link-lag, pipeline-context). The single owner is
-  // `_calendar`; this getter just delegates.
   get calendarReader() {
     return this._calendar.reader;
   }
-  // -- AutoSchedulerPort: mutations --------------------------------------------
   batchUpdate(runMutations) {
     runMutations();
   }
-  /**
-   * Part of the `AutoSchedulerPort` port (live caller: `applyResults`). No-op
-   * here because activities mutate in place via `getLiveActivity`; only a
-   * DHTMLX-backed adapter needs this to trigger a re-render.
-   */
   updateActivity(_id) {
   }
   getLiveActivity(activityId) {
     return this.getActivity(activityId);
   }
-  // -- AutoSchedulerPort: flags / config ---------------------------------------
   getFlags() {
     return {
       ...this._flags,
       allCheckedTaskIds: this._viewState.checkedIds()
     };
   }
-  // Backend ships no project-level dates, so this is always null in
-  // production. The ALAP root-boundary branch that reads it stays dormant.
   getProjectEnd() {
     return null;
   }
-  // -- Write capture (per-dispatch journal) --------------------------------
-  /** Start recording every `setActivityField` write of the current dispatch. */
   beginWriteCapture() {
     this._writeCapture.begin();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
     this._promotionSnapshotBefore = null;
   }
-  /** The live journal, or null when no capture is active. */
   peekWriteCapture() {
     return this._writeCapture.peek();
   }
-  /** Stop and discard the current dispatch's write journal. */
   endWriteCapture() {
     this._writeCapture.end();
     this._viewStateBefore = null;
     this._lastStartDateBefore = null;
     this._promotionSnapshotBefore = null;
   }
-  // -- Replay-specific mutators --------------------------------------------
   setActivityField(activityId, field, value) {
     const activity = this.getActivity(activityId);
     if (!activity) return;
@@ -16751,11 +16310,6 @@ var ScheduleState = class {
     this._writeCapture.noteLinkField(String(linkId), link);
     Reflect.set(link, field, value);
   }
-  /**
-   * Applies the backend identity returned after a successful persistence
-   * request. `proplannerId` is deliberately not a regular editable link field:
-   * it is boundary-owned identity and must never enter link-update/undo logic.
-   */
   setLinkProplannerId(linkId, proplannerId) {
     const link = this.getLink(linkId);
     if (!link) return;
@@ -16795,28 +16349,9 @@ var ScheduleState = class {
     this._cache.visualOrderIds = null;
     this._hierarchy.markDirty();
   }
-  /**
-   * Transactional rollback: invert every journaled mutation so the store returns
-   * to its pre-dispatch state. Consumed by the facade on a failed dispatch,
-   * BEFORE `endWriteCapture` discards the journal. Reverse-chronological replay,
-   * bucketed in the dependency order the red-team fixed (endpoints before links,
-   * re-inserts before re-adds). All writes are DIRECT (never through the
-   * journaling mutators) so the rollback does not re-journal itself. O(touched).
-   *
-   * NOTE: covers everything routed through setActivityField + the structural
-   * mutators (the whole handler phase). The autoscheduler's `applyResults` date
-   * writes bypass the journal and are not yet reverted here (transaction plan
-   * Stage 4) — a create that throws AFTER autoschedule leaves those dates, which
-   * is still strictly less corrupt than today's no-rollback.
-   */
-  /** Pre-sweep correlative_id of an activity the renumbering shifted. Journaled
-   * separately (the sweep bypasses setActivityField) so rollback can revert it. */
   noteCorrelativeBefore(activityId, before) {
     this._writeCapture.noteCorrelativeBefore(activityId, before);
   }
-  /** Pre-applyResults clone of an activity the autoscheduler will move. Journaled
-   * separately (applyResults bypasses setActivityField) so rollback can revert
-   * the scheduler's date writes. */
   noteScheduledBefore(activityId, current) {
     this._writeCapture.noteScheduledBefore(activityId, current);
   }
@@ -16834,6 +16369,7 @@ var ScheduleState = class {
     this._restoreActivityFields(before);
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
+      this.invalidateDerivedOrder();
     }
     if (this._promotionSnapshotBefore !== null) {
       this._promotionSnapshot = this._promotionSnapshotBefore;
@@ -16926,11 +16462,6 @@ function buildFlags(snapshot) {
   };
 }
 
-// src/shared/clone-domain-value.ts
-function cloneDomainValue(value) {
-  return structuredClone(value);
-}
-
 // src/init/read-api.ts
 function readActivity(state, id) {
   const activity = state.getActivity(id);
@@ -16964,7 +16495,7 @@ function readChildrenIds(state, parentId) {
     });
     return roots;
   }
-  return [...state.getChildren(key)].map(String);
+  return getChildrenInVisualOrder(key, state);
 }
 function readSelectedActivityIds(state) {
   return state.checkedIds().map(String);
@@ -17022,9 +16553,6 @@ function computeProjectWorkHours(calendars) {
 // src/internal/state/pipeline-context.ts
 function buildPipelineContext(adapter, options) {
   return {
-    // Same work-calendar engine instance used by the mock adapter so both
-    // halves of the replay (auto-scheduler + column pipelines) agree on
-    // working-time math.
     calendars: adapter.calendarReader,
     hierarchy: createStateBackedHierarchyReader(adapter),
     activityReader: createStateBackedActivityReader(adapter),
@@ -17041,6 +16569,21 @@ function willRunCriticalPath(action) {
 }
 
 // src/dispatch/undo/undo-entry.ts
+function buildHistoryChangeSet(changes) {
+  const activitiesWithoutAfter = changes.activities.map((entry) => ({
+    ...entry,
+    after: null
+  }));
+  const linksWithoutAfter = changes.links.map((entry) => ({
+    ...entry,
+    after: null
+  }));
+  return cloneDomainValue({
+    ...changes,
+    activities: activitiesWithoutAfter,
+    links: linksWithoutAfter
+  });
+}
 function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
   return { changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks };
 }
@@ -17096,7 +16639,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") {
+  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") {
     return "skip";
   }
   return "record";
@@ -17338,24 +16881,20 @@ var UndoRecorder = class {
   redoStack = [];
   _lastKey = null;
   _lastTime = 0;
-  /**
-   * Push a forward entry; a new action invalidates the redo branch. When the
-   * entry coalesces with the top one (same cell key, within the time window),
-   * it merges into the top step instead of pushing a new one (decision #4).
-   */
   record(entry, coalesceKey = null, now = 0) {
     const top = this.undoStack[this.undoStack.length - 1];
     if (coalesceKey != null && coalesceKey === this._lastKey && now - this._lastTime <= COALESCE_WINDOW_MS && top !== void 0 && canCoalesce(top, entry)) {
       this.undoStack[this.undoStack.length - 1] = mergeCoalesced(top, entry);
     } else {
       this.undoStack.push(entry);
-      if (this.undoStack.length > this.maxDepth) this.undoStack.shift();
+      if (this.undoStack.length > this.maxDepth) {
+        this.undoStack.splice(0, this.undoStack.length - this.maxDepth);
+      }
     }
     this._lastKey = coalesceKey;
     this._lastTime = now;
     this.redoStack.length = 0;
   }
-  /** Break the coalescing chain (called on undo/redo). */
   resetCoalesce() {
     this._lastKey = null;
   }
@@ -17387,13 +16926,48 @@ var UndoRecorder = class {
   }
 };
 
+// src/dispatch/shared/resequenced-parents.ts
+var POSITIONAL_FIELDS = ["parentId", "correlativeId"];
+function collectResequencedParents(changes, parentOf) {
+  const touched = /* @__PURE__ */ new Set();
+  const addParentOf = (activityId) => {
+    const parentId = parentOf(activityId);
+    touched.add(parentId === null ? ROOT_PARENT_ID : String(parentId));
+  };
+  for (const change of changes.activities) {
+    const activityId = String(change.id);
+    if (change.kind === "created") {
+      addParentOf(activityId);
+      continue;
+    }
+    if (change.kind === "deleted") {
+      const deletedFields = change.fields;
+      if (deletedFields && "parentId" in deletedFields) {
+        touched.add(parentKeyOf2(deletedFields.parentId?.before));
+      }
+      continue;
+    }
+    const fields = change.fields;
+    if (!fields) continue;
+    const movedPositionally = POSITIONAL_FIELDS.some(
+      (field) => field in fields
+    );
+    if (!movedPositionally) continue;
+    addParentOf(activityId);
+    if ("parentId" in fields) {
+      touched.add(parentKeyOf2(fields.parentId?.before));
+    }
+  }
+  return touched;
+}
+function parentKeyOf2(parentId) {
+  if (parentId === null || parentId === void 0) return ROOT_PARENT_ID;
+  return String(parentId);
+}
+
 // src/init/build-state-snapshot.ts
 function buildStoreLink(link) {
   return {
-    // Spread first to preserve passthrough backend fields (proplannerId,
-    // ganttId, sectorId) through the snapshot — dropping proplannerId here was
-    // a bug: the core lost each link's backend id, so save dirty-detection and
-    // the DHTMLX adapter could not tell persisted links from new ones.
     ...link,
     id: String(link.id),
     source: String(link.source),
@@ -17406,11 +16980,6 @@ function serializeWorktime(worktime) {
   return {
     days: worktime.days,
     hours: worktime.hours,
-    // Preserve per-date overrides (holidays + workday shift exceptions)
-    // through the snapshot so the work-calendar engine sees them when
-    // the state hydrates. Dropping these here was the bug that made
-    // multi-shift / exception-day calendars snap to wrong hours after
-    // every edit.
     ...worktime.dates ? { dates: worktime.dates } : {},
     ...worktime.customWeeks ? { customWeeks: worktime.customWeeks } : {}
   };
@@ -17527,13 +17096,11 @@ var SaveTracker = class {
   initialized = false;
   linksAtLastSave = /* @__PURE__ */ new Map();
   activitiesAtLastSave = /* @__PURE__ */ new Map();
-  /** Take the initial snapshot once (after the autoscheduler settles). */
   init(activities, links) {
     this.snapshotActivities(activities);
     this.snapshotLinks(links);
     this.initialized = true;
   }
-  /** Re-snapshot activities (call after a save persists them). */
   snapshotActivities(activities) {
     this.activitiesAtLastSave.clear();
     for (const activity of activities) {
@@ -17544,7 +17111,6 @@ var SaveTracker = class {
       );
     }
   }
-  /** Re-snapshot links (call after a save persists them). */
   snapshotLinks(links) {
     this.linksAtLastSave.clear();
     for (const link of links) {
@@ -17555,7 +17121,6 @@ var SaveTracker = class {
       });
     }
   }
-  /** Persisted activities whose value changed since the last snapshot. */
   modifiedActivities(activities) {
     if (!this.initialized) return [];
     return activities.filter((activity) => {
@@ -17566,7 +17131,6 @@ var SaveTracker = class {
       return activityChangedSince(activity, saved);
     });
   }
-  /** Persisted links whose `lag`/`type` changed since the last snapshot. */
   modifiedLinks(links) {
     if (!this.initialized) return [];
     return links.filter((link) => {
@@ -17576,7 +17140,6 @@ var SaveTracker = class {
       return link.lag !== saved.lag || link.type !== saved.type;
     });
   }
-  /** Drop both mirrors (teardown). */
   clear() {
     this.linksAtLastSave.clear();
     this.activitiesAtLastSave.clear();
@@ -18346,35 +17909,58 @@ function cloneStats(stats) {
 var CustomIdTracker = class {
   prefixMap = /* @__PURE__ */ new Map();
   processedIds = /* @__PURE__ */ new Set();
-  _journal = null;
+  _journalPrefixBefore = null;
+  _journalIds = null;
   beginCustomIdTransaction() {
-    this._journal = [];
+    this._journalPrefixBefore = /* @__PURE__ */ new Map();
+    this._journalIds = [];
   }
   commitCustomIdTransaction() {
-    this._journal = null;
+    this._journalPrefixBefore = null;
+    this._journalIds = null;
   }
   rollbackCustomIdTransaction() {
-    const journal = this._journal;
-    if (journal === null) return;
-    for (const entry of [...journal].reverse()) {
-      const { prefix } = this.analyzeCustomId(entry.customId);
-      if (entry.prefixBefore === null) this.prefixMap.delete(prefix);
-      else this.prefixMap.set(prefix, entry.prefixBefore);
+    const prefixBeforeByPrefix = this._journalPrefixBefore;
+    const journaledIds = this._journalIds;
+    if (prefixBeforeByPrefix === null || journaledIds === null) return;
+    for (const [prefix, statsBefore] of prefixBeforeByPrefix) {
+      if (statsBefore === null) this.prefixMap.delete(prefix);
+      else this.prefixMap.set(prefix, statsBefore);
+    }
+    for (const entry of [...journaledIds].reverse()) {
       if (entry.hadId) this.processedIds.add(entry.customId);
       else this.processedIds.delete(entry.customId);
     }
-    this._journal = null;
+    this._journalPrefixBefore = null;
+    this._journalIds = null;
   }
   _noteCustomIdBefore(customId) {
-    if (this._journal === null) return;
+    if (this._journalPrefixBefore === null || this._journalIds === null) {
+      return;
+    }
     const { prefix } = this.analyzeCustomId(customId);
-    const current = this.prefixMap.get(prefix);
-    this._journal.push({
+    if (!this._journalPrefixBefore.has(prefix)) {
+      const current = this.prefixMap.get(prefix);
+      this._journalPrefixBefore.set(
+        prefix,
+        current ? cloneStats(current) : null
+      );
+    }
+    this._journalIds.push({
       customId,
-      prefixBefore: current ? cloneStats(current) : null,
       hadId: this.processedIds.has(customId)
     });
   }
+  _ensureFreshBounds(prefix) {
+    const stats = this.prefixMap.get(prefix);
+    if (!stats?.boundsDirty) return;
+    stats.boundsDirty = false;
+    const remaining = Array.from(stats.usedSuffixes);
+    stats.min = minSuffixFromArray(remaining);
+    stats.max = maxSuffixFromArray(remaining);
+    stats.quantity = remaining.length;
+    this._recalculateNext(prefix);
+  }
   defaultPrefix;
   suffixIncrement;
   constructor(options = {}) {
@@ -18394,6 +17980,7 @@ var CustomIdTracker = class {
     };
   }
   _updatePrefixStats(prefix, suffix) {
+    this._ensureFreshBounds(prefix);
     if (!this.prefixMap.has(prefix)) {
       this.prefixMap.set(prefix, {
         min: suffix,
@@ -18420,6 +18007,7 @@ var CustomIdTracker = class {
     stats.next = next ?? this.suffixIncrement;
   }
   getPrefixStats(prefix) {
+    this._ensureFreshBounds(prefix);
     const stats = this.prefixMap.get(prefix);
     if (!stats) return null;
     return {
@@ -18430,6 +18018,7 @@ var CustomIdTracker = class {
     };
   }
   getNextSuffix(prefix) {
+    this._ensureFreshBounds(prefix);
     const stats = this.prefixMap.get(prefix);
     return stats ? stats.next : this.suffixIncrement;
   }
@@ -18443,6 +18032,7 @@ var CustomIdTracker = class {
     const { prefix, suffix } = this.analyzeCustomId(customId);
     if (!prefix && !suffix) return { prefix, suffix };
     this._noteCustomIdBefore(customId);
+    this._ensureFreshBounds(prefix);
     if (this.prefixMap.has(prefix)) {
       const stats = this.prefixMap.get(prefix);
       if (!stats.usedSuffixes.has(suffix)) {
@@ -18473,22 +18063,12 @@ var CustomIdTracker = class {
     this._noteCustomIdBefore(customId);
     const currentStats = this.prefixMap.get(prefix);
     if (currentStats.usedSuffixes.has(suffix)) {
-      const newQuantity = currentStats.quantity - 1;
-      if (newQuantity === 0) {
+      currentStats.usedSuffixes.delete(suffix);
+      currentStats.quantity -= 1;
+      if (currentStats.usedSuffixes.size === 0) {
         this.prefixMap.delete(prefix);
       } else {
-        const newUsed = new Set(currentStats.usedSuffixes);
-        newUsed.delete(suffix);
-        const remaining = Array.from(newUsed);
-        if (remaining.length === 0) {
-          this.prefixMap.delete(prefix);
-        } else {
-          currentStats.usedSuffixes = newUsed;
-          currentStats.min = minSuffixFromArray(remaining);
-          currentStats.max = maxSuffixFromArray(remaining);
-          currentStats.quantity = newQuantity;
-          this._recalculateNext(prefix);
-        }
+        currentStats.boundsDirty = true;
       }
     }
     this.processedIds.delete(customId);
@@ -18508,12 +18088,19 @@ var CustomIdTracker = class {
     return customId.length > MAX_CUSTOM_ID_LENGTH;
   }
   _shouldSearchForGaps(prefix) {
+    this._ensureFreshBounds(prefix);
     if (!this.prefixMap.has(prefix)) return false;
     const stats = this.prefixMap.get(prefix);
     const nextWouldBe = `${prefix}${addToSuffix(stats.max, this.suffixIncrement)}`;
     return nextWouldBe.length > MAX_CUSTOM_ID_LENGTH;
   }
+  _suffixForUnknownPrefix(prefix, baseSuffix) {
+    const candidate = baseSuffix && isValidSuffix(baseSuffix) ? baseSuffix : this.suffixIncrement;
+    if (`${prefix}${candidate}`.length > MAX_CUSTOM_ID_LENGTH) return null;
+    return candidate;
+  }
   _findFirstAvailableGap(prefix) {
+    this._ensureFreshBounds(prefix);
     if (!this.prefixMap.has(prefix)) return null;
     const stats = this.prefixMap.get(prefix);
     let candidate = this.suffixIncrement;
@@ -18537,10 +18124,9 @@ var CustomIdTracker = class {
     return `${this.defaultPrefix}${nextSuffix}`;
   }
   getNextAvailableSuffix(prefix, baseSuffix = null) {
+    this._ensureFreshBounds(prefix);
     if (!this.prefixMap.has(prefix)) {
-      const candidate2 = baseSuffix && isValidSuffix(baseSuffix) ? baseSuffix : this.suffixIncrement;
-      if (`${prefix}${candidate2}`.length > MAX_CUSTOM_ID_LENGTH) return null;
-      return candidate2;
+      return this._suffixForUnknownPrefix(prefix, baseSuffix);
     }
     const stats = this.prefixMap.get(prefix);
     const step = this.suffixIncrement;
@@ -18581,9 +18167,6 @@ var CustomIdTracker = class {
     }
     return generatedId;
   }
-  /**
-   * Seed the tracker from an array of activities. Idempotent.
-   */
   populateFromActivities(activities) {
     if (!Array.isArray(activities)) return this;
     const uniqueCustomIds = [
@@ -18604,14 +18187,6 @@ var CustomIdTracker = class {
   getDefaults() {
     return { prefix: this.defaultPrefix, increment: this.suffixIncrement };
   }
-  /**
-   * Generates a custom ID for a new child activity.
-   *
-   * Three strategies (see `selectGenerationStrategy`):
-   *   - parentConversion: parent has customId → release it, child uses defaults.
-   *   - pasteReference:   reference has customId → use its prefix + suffix as base.
-   *   - noContext:        no reference → use defaults.
-   */
   generateCustomIdForNewChild(params) {
     const { activity, useActivityCustomIdAsReference = false } = params;
     const customId = getCustomIdFromActivity(activity);
@@ -18625,6 +18200,7 @@ var CustomIdTracker = class {
     );
     let capturedNextSuffix = null;
     if (strategyKey === "parentConversion" && this.prefixMap.has(prefix)) {
+      this._ensureFreshBounds(prefix);
       const currentMax = this.prefixMap.get(prefix).max;
       capturedNextSuffix = addToSuffix(currentMax, this.suffixIncrement);
     }
@@ -18655,11 +18231,6 @@ var CustomIdTracker = class {
         return noContextStrategy(this.defaultPrefix);
     }
   }
-  /**
-   * Generates customId for parent-to-child conversion after outdent demote.
-   * If `siblingCustomId` is provided, follows its pattern (prefix + next
-   * suffix). Otherwise uses defaults.
-   */
   generateCustomIdForRestoredChild(siblingCustomId = null) {
     if (siblingCustomId) {
       const trimmed = siblingCustomId.trim();
@@ -18695,11 +18266,6 @@ var CustomIdTracker = class {
   hasPrefix(prefix) {
     return this.prefixMap.has(prefix);
   }
-  /**
-   * O(1) check — used by inline-edit to validate "no duplicate". When
-   * `currentCustomId` is passed, returns false if the new value matches
-   * (no-op edit). Used by the dispatch's `customIdPipeline.validate`.
-   */
   isCustomIdInUse(customId, currentCustomId = null) {
     if (!customId || typeof customId !== "string" || !customId.trim()) {
       return false;
@@ -18712,6 +18278,65 @@ var CustomIdTracker = class {
   }
 };
 
+// src/internal/order/build-comparator.ts
+var MISSING_LAST = 1;
+var MISSING_FIRST = -1;
+function compareMissing(aMissing, bMissing) {
+  if (!aMissing && !bMissing) return null;
+  if (aMissing && bMissing) return 0;
+  return aMissing ? MISSING_LAST : MISSING_FIRST;
+}
+function isMissing(value) {
+  return value === null || value === void 0;
+}
+function enumRank(value, order) {
+  const index = order.indexOf(String(value));
+  return index === -1 ? order.length : index;
+}
+function compareValues(a, b, locale) {
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() - b.getTime();
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return Number(a) - Number(b);
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length - b.length;
+  }
+  return String(a).localeCompare(String(b), locale, {
+    sensitivity: "base",
+    numeric: true
+  });
+}
+function compareByRule(rule, context) {
+  const descriptor = getFieldDescriptor(rule.field);
+  if (descriptor === null) return null;
+  return (a, b) => {
+    const valueA = descriptor.extract(a, context);
+    const valueB = descriptor.extract(b, context);
+    const missing = compareMissing(isMissing(valueA), isMissing(valueB));
+    if (missing !== null) return missing;
+    const result = descriptor.valueKind === "enum" ? enumRank(valueA, descriptor.order) - enumRank(valueB, descriptor.order) : compareValues(valueA, valueB, context.locale);
+    return rule.direction === "desc" ? -result : result;
+  };
+}
+function buildComparator(order, context) {
+  const comparators = order.rules.map((rule) => compareByRule(rule, context)).filter(
+    (comparator) => comparator !== null
+  );
+  if (comparators.length === 0) return null;
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) return result;
+    }
+    return 0;
+  };
+}
+
 // src/internal/post-processors/demote-childless-summaries.ts
 function demoteChildlessSummaries(state) {
   const idsToDemote = [];
@@ -18866,8 +18491,6 @@ function normalizeMilestoneConstraintDatesForDisplay(state) {
 var SCHEDULE_CORE_STATUS = {
   READY: "ready",
   DESTROYED: "destroyed",
-  /** A rollback failed mid-restore — state may be inconsistent; the host must
-   * reload from backend. All further dispatches are refused. */
   POISONED: "poisoned"
 };
 function initializeCore(input) {
@@ -18894,7 +18517,8 @@ function initializeCore(input) {
     parsed2.calendars,
     baseCalendars
   );
-  const state = new ScheduleState(snapshot);
+  const buildOrderComparator = (order) => buildComparator(order, buildFilterContext(sector.hoursPerDay));
+  const state = new ScheduleState(snapshot, buildOrderComparator);
   state.hydrateViewState({ hiddenIds: parsed2.viewStateSeed.hiddenIds });
   const scheduler = new AutoScheduler(state, reporter);
   demoteChildlessSummaries(state);
@@ -18927,9 +18551,6 @@ function initializeCore(input) {
     sector,
     scheduler,
     skipAutoSchedule: input.skipInitialAutoSchedule === true,
-    // `loadNow` is rounded to end-of-local-day (legacy `calculateExpected`
-    // parity) — the LOAD expected_progress pass. Dispatch-time recomputes call
-    // `clock()` fresh, so a long-lived session tracks the real day.
     now: loadNow ?? void 0
   });
   return {
@@ -19045,13 +18666,18 @@ var ScheduleCore = class {
     this.assertReady();
     return readSelectedActivityIds(this.coreRuntime.state);
   }
-  /**
-   * Every activity id in canonical DFS visual order (pre-order from roots,
-   * siblings by `correlative_id` ASC) — ALL activities; filtering by
-   * `visible` is the consumer's job. Memoized in the state and invalidated
-   * on any structural mutation (add/remove/reparent/renumber), so repeated
-   * reads between mutations are O(1).
-   */
+  getHiddenActivityIds() {
+    this.assertReady();
+    return this.coreRuntime.state.hiddenIds().map(String);
+  }
+  getActiveFilter() {
+    this.assertReady();
+    return this.coreRuntime.state.getActiveFilter();
+  }
+  getActiveOrder() {
+    this.assertReady();
+    return this.coreRuntime.state.getActiveOrder();
+  }
   getVisualOrderIds() {
     this.assertReady();
     return [...this.coreRuntime.state.getVisualOrderIds()];
@@ -19151,7 +18777,7 @@ var ScheduleCore = class {
       );
       this._undo.record(
         buildUndoEntry(
-          result.changes,
+          buildHistoryChangeSet(result.changes),
           result.__beforeSnap,
           result.__beforeLinks,
           created.afterSnap,
@@ -19168,19 +18794,13 @@ var ScheduleCore = class {
       this._saveTracker.snapshotLinks(this.getAllLinksView());
       this._undo.clear();
     }
+    result = this._withReappliedViewState(action, result);
     if (!result.ok) return result;
     if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
       this._recordScheduleMutation(options.skipCriticalPath !== true);
     }
-    return cloneDomainValue(result);
+    return toPublicDispatchResult(result);
   }
-  /**
-   * Starts or joins the Critical Path calculation for the current schedule
-   * revision. Snapshot capture and the final commit are serialized with user
-   * mutations, but the expensive calculation runs outside `_opQueue` against
-   * an isolated state. A newer revision aborts this job and makes its result
-   * ineligible to commit.
-   */
   recomputeCriticalPath() {
     const operation = this._enqueue(async () => ({
       job: this._startCriticalPathForCurrentRevision()
@@ -19196,6 +18816,99 @@ var ScheduleCore = class {
       await this.recomputeCriticalPath();
     }
   }
+  _withReappliedViewState(action, result) {
+    if (!result.ok || !reappliesViewState(action)) return result;
+    const merged = this._reapplyViewState(result.changes);
+    return merged === null ? result : { ...result, changes: merged };
+  }
+  /**
+   * The single place the two view-state passes are chained. Dispatch, undo and
+   * redo all route through here: when this existed only inside the dispatch
+   * path, undo and redo reapplied the filter and forgot the order, so an edit
+   * that moved a row and was then undone left the row in its new position.
+   *
+   * The sequence between the passes is indifferent. Filter and order are
+   * orthogonal projections over the same tree — the filter decides which rows
+   * exist on screen and never reads the order; the order sequences every
+   * sibling group from the hierarchy index and never reads visibility. Either
+   * sequence produces the same ChangeSet.
+   *
+   * Both passes answer null while their state is inactive, so an unfiltered,
+   * unsorted schedule pays two property reads.
+   */
+  _reapplyViewState(changes) {
+    const withFilter = this._reapplyActiveFilter(changes);
+    const withOrder = this._reapplyActiveOrder(withFilter ?? changes);
+    const sequenced = this._emitTouchedBranchOrder(
+      withOrder ?? withFilter ?? changes
+    );
+    return sequenced ?? withOrder ?? withFilter;
+  }
+  /**
+   * Emits `order` for the branches this mutation resequenced, when no user order
+   * is active.
+   *
+   * The contract is that `order` reports a CHANGED SEQUENCE, not the presence of
+   * a sort. Tying emission to the cause instead of the effect is what produced
+   * the undo bug and, later, the reparent ones: without an active order a move,
+   * an indent, an outdent or the undo of any of them rearranged rows and said
+   * nothing, so an incremental consumer kept the old sequence. The undo of a
+   * reparent was the worst of them — it carried neither `order` nor a single
+   * correlativeId, so the position was not recoverable by any consumer.
+   *
+   * The touched branches are derived from the ChangeSet rather than accumulated
+   * in the state: an entity whose parentId or correlativeId moved, plus the
+   * parents of created and deleted rows, is exactly the set of branches whose
+   * sequence can differ. That keeps this linear in the blast radius, adds
+   * nothing to the write path, and cannot leak across dispatches.
+   */
+  _emitTouchedBranchOrder(changes) {
+    const adapter = this.coreRuntime.state;
+    if (adapter.getActiveOrder() !== null) return null;
+    const touched = collectResequencedParents(
+      changes,
+      (activityId) => adapter.getParentId(activityId)
+    );
+    if (touched.size === 0) return null;
+    const order = [...touched].map((parentId) => ({
+      parentId,
+      childIds: getChildrenInVisualOrder(parentId, adapter)
+    })).filter((branch) => branch.childIds.length > 1);
+    if (order.length === 0) return null;
+    return { ...changes, order };
+  }
+  /**
+   * Re-sequences the grid after any mutation that could have changed a value the
+   * active order sorts by. Ordering is a view over the data, so an edit that
+   * moves a row past its sibling must move the row, exactly as the filter makes
+   * a no-longer-matching row disappear.
+   *
+   * Production only re-sorts after a bar drag; diverging from that is a
+   * deliberate product decision, not an oversight.
+   */
+  _reapplyActiveOrder(changes) {
+    const adapter = this.coreRuntime.state;
+    if (adapter.getActiveOrder() === null) return null;
+    adapter.invalidateDerivedOrder();
+    return { ...changes, order: collectBranchOrder(adapter) };
+  }
+  _reapplyActiveFilter(changes) {
+    const filter = this.coreRuntime.state.getActiveFilter();
+    if (filter === null) return null;
+    const adapter = this.coreRuntime.state;
+    const visibleIds = evaluateVisibleIds({
+      activities: adapter.getAllActivities(),
+      parentOf: (activityId) => adapter.getParentId(activityId),
+      filter,
+      context: buildFilterContext(this.coreRuntime.sector.hoursPerDay)
+    });
+    const viewState = applyVisibleSet(adapter, visibleIds);
+    if (viewState.length === 0) return null;
+    return {
+      ...changes,
+      viewState: [...changes.viewState ?? [], ...viewState]
+    };
+  }
   _recordScheduleMutation(criticalPathIsFresh) {
     this._scheduleRevision++;
     if (this._activeCriticalPath) {
@@ -19246,7 +18959,7 @@ var ScheduleCore = class {
           for (const [activityId, fields] of fieldsByActivity) {
             this.coreRuntime.state.setActivityFields(activityId, fields);
           }
-          changes = assembleChangeSet(this.coreRuntime.state, {
+          changes = await assembleChangeSet(this.coreRuntime.state, {
             source: { kind: "init" },
             beforeSnap: /* @__PURE__ */ new Map(),
             touchedIds: [],
@@ -19273,7 +18986,6 @@ var ScheduleCore = class {
     void promise.then(clearIfActive, clearIfActive);
     return promise;
   }
-  // bridge-load artifact: emits HOURS (no duration/lag diff anyway; bridge applies verbatim).
   async _runCriticalPathAndCapture() {
     if (this._status === SCHEDULE_CORE_STATUS.DESTROYED) {
       return {
@@ -19294,7 +19006,7 @@ var ScheduleCore = class {
         this.coreRuntime.state,
         this.coreRuntime.sector.hoursPerDay
       );
-      changes = assembleChangeSet(this.coreRuntime.state, {
+      changes = await assembleChangeSet(this.coreRuntime.state, {
         source: { kind: "init" },
         beforeSnap: /* @__PURE__ */ new Map(),
         touchedIds: [],
@@ -19307,11 +19019,6 @@ var ScheduleCore = class {
     }
     return { changes };
   }
-  /**
-   * Undo/Redo restores the user's historical mutation while retaining current
-   * non-historical truth (for example a refreshed baseline). Re-derive every
-   * value that depends on both so the restored model is immediately coherent.
-   */
   _recomputeAfterHistoryRestore() {
     const state = this.coreRuntime.state;
     recomputeAllProgressRollup(state);
@@ -19347,7 +19054,12 @@ var ScheduleCore = class {
       if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
       this._undo.pushRedo(entry);
       this._undo.resetCoalesce();
-      return buildInverseChangeSet(this.coreRuntime.state, entry, "before");
+      const changes = buildInverseChangeSet(
+        this.coreRuntime.state,
+        entry,
+        "before"
+      );
+      return this._reapplyViewState(changes) ?? changes;
     });
     void operation.then(
       (changes) => {
@@ -19375,7 +19087,12 @@ var ScheduleCore = class {
       if (needsResync(entry)) this._resyncCustomIdTrackerFromModel();
       this._undo.pushUndo(entry);
       this._undo.resetCoalesce();
-      return buildInverseChangeSet(this.coreRuntime.state, entry, "after");
+      const changes = buildInverseChangeSet(
+        this.coreRuntime.state,
+        entry,
+        "after"
+      );
+      return this._reapplyViewState(changes) ?? changes;
     });
     void operation.then(
       (changes) => {
@@ -19398,11 +19115,6 @@ var ScheduleCore = class {
   canRedo() {
     return this._undo.canRedo();
   }
-  /**
-   * Establishes a new persistence boundary without mutating schedule state.
-   * Completed saves call this synchronously so neither prior undo entries nor
-   * their redo branch can cross the persisted boundary.
-   */
   clearHistory() {
     this._undo.clear();
   }
@@ -19437,13 +19149,6 @@ var ScheduleCore = class {
       );
     }
   }
-  /**
-   * Revert the current dispatch's mutations from the write-capture journal. If
-   * the restore ITSELF throws, the state may be a third, partially-inverted
-   * state — worse than either endpoint — so poison the core: refuse all further
-   * dispatches and surface the fault so the host reloads from backend. A failed
-   * rollback is never swallowed.
-   */
   _rollback() {
     try {
       this.coreRuntime.state.restoreFromCapture();
@@ -19458,6 +19163,14 @@ var ScheduleCore = class {
     }
   }
 };
+function toPublicDispatchResult(result) {
+  const {
+    __beforeSnap: droppedSnapshots,
+    __beforeLinks: droppedLinks,
+    ...publicResult
+  } = result;
+  return publicResult;
+}
 
 // src/boundary/save/link-changes.ts
 function checkNoUpdatedLinks(baseline, current) {
@@ -19512,6 +19225,8 @@ var DISPATCH_ACTION_KIND = {
   SELECTION_TOGGLE: "selection-toggle",
   SELECTION_REPLACE: "selection-replace",
   VISIBILITY_SET: "visibility-set",
+  FILTER_SET: "filter-set",
+  SORT_SET: "sort-set",
   SIR_SYNC: "sir-sync",
   ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
 };
@@ -19537,6 +19252,8 @@ var KIND_CATALOG_COVERS_UNION = {
   [DISPATCH_ACTION_KIND.SELECTION_TOGGLE]: true,
   [DISPATCH_ACTION_KIND.SELECTION_REPLACE]: true,
   [DISPATCH_ACTION_KIND.VISIBILITY_SET]: true,
+  [DISPATCH_ACTION_KIND.FILTER_SET]: true,
+  [DISPATCH_ACTION_KIND.SORT_SET]: true,
   [DISPATCH_ACTION_KIND.SIR_SYNC]: true,
   [DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC]: true
 };