@outbuild-company/schedule-core 1.9.0 → 1.9.2

package/dist/index.cjs

@@ -401,16 +401,10 @@ var FIELD_REGISTRY = {
     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
@@ -420,107 +414,6 @@ function getFieldDescriptor(field) {
   return FIELD_REGISTRY[field] ?? null;
 }
 
-// src/internal/state/view-state.ts
-function isRelativePlacementPinValid(activityId, pin, parentOf) {
-  const branchParentId = String(pin.branchParentId);
-  const currentParentId = String(parentOf(activityId) ?? "0");
-  if (currentParentId !== branchParentId) return false;
-  const referenceId = String(pin.referenceId);
-  return referenceId === branchParentId || String(parentOf(referenceId) ?? "0") === branchParentId;
-}
-var ViewStateStore = class {
-  checkedSet = /* @__PURE__ */ new Set();
-  hiddenSet = /* @__PURE__ */ new Set();
-  activeFilter = null;
-  activeOrder = null;
-  relativePlacementPins = /* @__PURE__ */ new Map();
-  isChecked(activityId) {
-    return this.checkedSet.has(activityId);
-  }
-  isVisible(activityId) {
-    return !this.hiddenSet.has(activityId);
-  }
-  hiddenIds() {
-    return [...this.hiddenSet];
-  }
-  getActiveFilter() {
-    return this.activeFilter;
-  }
-  setActiveFilter(nextFilter) {
-    this.activeFilter = nextFilter;
-  }
-  getActiveOrder() {
-    return this.activeOrder;
-  }
-  setActiveOrder(nextOrder) {
-    this.activeOrder = nextOrder;
-  }
-  setRelativePlacementPin(activityId, pin) {
-    this.relativePlacementPins.set(String(activityId), {
-      referenceId: String(pin.referenceId),
-      branchParentId: String(pin.branchParentId),
-      side: pin.side
-    });
-  }
-  getRelativePlacementPins() {
-    return this.relativePlacementPins;
-  }
-  restoreRelativePlacementPins(pins) {
-    this.relativePlacementPins = new Map(pins);
-  }
-  checkedIds() {
-    return [...this.checkedSet];
-  }
-  checkedCount() {
-    return this.checkedSet.size;
-  }
-  setChecked(activityId, nextChecked) {
-    if (nextChecked === this.checkedSet.has(activityId)) return false;
-    if (nextChecked) this.checkedSet.add(activityId);
-    else this.checkedSet.delete(activityId);
-    return true;
-  }
-  setVisible(activityId, nextVisible) {
-    if (nextVisible === !this.hiddenSet.has(activityId)) return false;
-    if (nextVisible) this.hiddenSet.delete(activityId);
-    else this.hiddenSet.add(activityId);
-    return true;
-  }
-  forget(activityId) {
-    this.checkedSet.delete(activityId);
-    this.hiddenSet.delete(activityId);
-    this.relativePlacementPins.delete(activityId);
-    for (const [pinnedId, pin] of this.relativePlacementPins) {
-      if (pin.referenceId === activityId) {
-        this.relativePlacementPins.delete(pinnedId);
-      }
-    }
-  }
-  hydrate(seed2) {
-    this.checkedSet = new Set(seed2.checkedIds ?? []);
-    this.hiddenSet = new Set(seed2.hiddenIds ?? []);
-    this.activeFilter = null;
-    this.activeOrder = null;
-    this.relativePlacementPins = /* @__PURE__ */ new Map();
-  }
-  snapshot() {
-    return {
-      checked: new Set(this.checkedSet),
-      hidden: new Set(this.hiddenSet),
-      activeFilter: this.activeFilter,
-      activeOrder: this.activeOrder,
-      relativePlacementPins: new Map(this.relativePlacementPins)
-    };
-  }
-  restore(snapshot) {
-    this.checkedSet = new Set(snapshot.checked);
-    this.hiddenSet = new Set(snapshot.hidden);
-    this.activeFilter = snapshot.activeFilter;
-    this.activeOrder = snapshot.activeOrder;
-    this.relativePlacementPins = new Map(snapshot.relativePlacementPins);
-  }
-};
-
 // src/internal/filter/evaluate-filter.ts
 function toTargetDate(value) {
   if (value instanceof Date) return value;
@@ -647,7 +540,6 @@ function evaluateVisibleIds(input) {
 function seedFilterProjection(input) {
   const { activities, parentOf, filter, context } = input;
   const matchedIds = /* @__PURE__ */ new Set();
-  const pinnedVisibleIds = /* @__PURE__ */ new Set();
   const visibleReferenceCounts = /* @__PURE__ */ new Map();
   const parentIds = /* @__PURE__ */ new Map();
   const remainingChildren = /* @__PURE__ */ new Map();
@@ -668,35 +560,11 @@ function seedFilterProjection(input) {
   }
   return {
     matchedIds,
-    pinnedVisibleIds,
     visibleReferenceCounts,
     parentIds,
     remainingChildren
   };
 }
-function applyRelativePlacementPins(seed2, pins) {
-  if (pins === void 0) return;
-  for (const [activityId, pin] of pins) {
-    const pinnedId = String(activityId);
-    const referenceId = String(pin.referenceId);
-    if (!seed2.parentIds.has(pinnedId) || !seed2.parentIds.has(referenceId) || !isRelativePlacementPinValid(
-      pinnedId,
-      pin,
-      (activityId2) => seed2.parentIds.get(activityId2) ?? null
-    ) || (seed2.visibleReferenceCounts.get(referenceId) ?? 0) === 0) {
-      continue;
-    }
-    seed2.pinnedVisibleIds.add(pinnedId);
-    let currentId = pinnedId;
-    while (currentId !== null) {
-      seed2.visibleReferenceCounts.set(
-        currentId,
-        (seed2.visibleReferenceCounts.get(currentId) ?? 0) + 1
-      );
-      currentId = seed2.parentIds.get(currentId) ?? null;
-    }
-  }
-}
 function propagateVisibleReferenceCounts(seed2) {
   const { visibleReferenceCounts, parentIds, remainingChildren } = seed2;
   const pendingIds = [];
@@ -728,13 +596,11 @@ function collectVisibleIds(visibleReferenceCounts) {
 function buildFilterProjection(input) {
   const seed2 = seedFilterProjection(input);
   propagateVisibleReferenceCounts(seed2);
-  applyRelativePlacementPins(seed2, input.relativePlacementPins);
   const visibleIds = collectVisibleIds(seed2.visibleReferenceCounts);
   return {
     filter: input.filter,
     context: input.context,
     matchedIds: seed2.matchedIds,
-    pinnedVisibleIds: seed2.pinnedVisibleIds,
     visibleIds,
     visibleReferenceCounts: seed2.visibleReferenceCounts
   };
@@ -792,8 +658,6 @@ var OPERATORS_BY_KIND = {
   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"])
 };
@@ -916,8 +780,7 @@ function resolveFilter(adapter, filter, hoursPerDay) {
     activities,
     parentOf: (activityId) => adapter.getParentId(activityId),
     filter,
-    context: buildFilterContext(hoursPerDay),
-    relativePlacementPins: adapter.getRelativePlacementPins()
+    context: buildFilterContext(hoursPerDay)
   });
   return { visibleIds: projection.visibleIds, projection };
 }
@@ -968,118 +831,25 @@ function normalizeParentKey(parent) {
 
 // src/internal/hierarchy/visual-order.ts
 var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-var EMPTY_RELATIVE_PLACEMENT_PINS = /* @__PURE__ */ new Map();
-function buildRelativePlacementPinIndex(adapter) {
-  const index = /* @__PURE__ */ new Map();
-  for (const [activityId, pin] of adapter.getRelativePlacementPins?.() ?? []) {
-    const pinnedId = String(activityId);
-    const referenceId = String(pin.referenceId);
-    if (adapter.getActivity(pinnedId) === null || adapter.getActivity(referenceId) === null || !isRelativePlacementPinValid(
-      pinnedId,
-      pin,
-      (activityId2) => adapter.getParentId(activityId2)
-    )) {
-      continue;
-    }
-    const targetParentId = String(pin.branchParentId);
-    const branchPins = index.get(targetParentId) ?? /* @__PURE__ */ new Map();
-    branchPins.set(pinnedId, pin);
-    index.set(targetParentId, branchPins);
-  }
-  return index;
-}
-function getChildrenInVisualOrder(parentId, adapter, pinIndex = buildRelativePlacementPinIndex(adapter)) {
+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 applyRelativePlacementPins2(
-    children.map((activity) => String(activity.id)),
-    parentId,
-    pinIndex.get(String(parentId)) ?? EMPTY_RELATIVE_PLACEMENT_PINS
-  );
-}
-function applyRelativePlacementPins2(orderedIds, parentId, pins) {
-  const order = buildLinkedActivityOrder(orderedIds);
-  for (const [activityId, pin] of pins) {
-    const pinnedId = String(activityId);
-    const referenceId = String(pin.referenceId);
-    const isFirstChild = referenceId === String(parentId);
-    if (!order.previous.has(pinnedId) || !isFirstChild && (!order.previous.has(referenceId) || pinnedId === referenceId)) {
-      continue;
-    }
-    detachActivity(order, pinnedId);
-    if (isFirstChild) insertActivityFirst(order, pinnedId);
-    else insertActivityBeside(order, pinnedId, referenceId, pin.side);
-  }
-  return materializeActivityOrder(order);
-}
-function buildLinkedActivityOrder(orderedIds) {
-  const previous = /* @__PURE__ */ new Map();
-  const next = /* @__PURE__ */ new Map();
-  for (let index = 0; index < orderedIds.length; index++) {
-    const activityId = orderedIds[index];
-    if (activityId === void 0) continue;
-    previous.set(activityId, orderedIds[index - 1] ?? null);
-    next.set(activityId, orderedIds[index + 1] ?? null);
-  }
-  return { previous, next, head: orderedIds[0] ?? null };
-}
-function detachActivity(order, activityId) {
-  const before = order.previous.get(activityId) ?? null;
-  const after = order.next.get(activityId) ?? null;
-  if (before === null) order.head = after;
-  else order.next.set(before, after);
-  if (after !== null) order.previous.set(after, before);
-}
-function insertActivityFirst(order, activityId) {
-  order.previous.set(activityId, null);
-  order.next.set(activityId, order.head);
-  if (order.head !== null) order.previous.set(order.head, activityId);
-  order.head = activityId;
-}
-function insertActivityBeside(order, activityId, referenceId, side) {
-  if (side === "before") {
-    const before = order.previous.get(referenceId) ?? null;
-    order.previous.set(activityId, before);
-    order.next.set(activityId, referenceId);
-    order.previous.set(referenceId, activityId);
-    if (before === null) order.head = activityId;
-    else order.next.set(before, activityId);
-    return;
-  }
-  const after = order.next.get(referenceId) ?? null;
-  order.previous.set(activityId, referenceId);
-  order.next.set(activityId, after);
-  order.next.set(referenceId, activityId);
-  if (after !== null) order.previous.set(after, activityId);
-}
-function materializeActivityOrder(order) {
-  const result = [];
-  let activityId = order.head;
-  while (activityId !== null) {
-    result.push(activityId);
-    activityId = order.next.get(activityId) ?? null;
-  }
-  return result;
+  return children.map((activity) => String(activity.id));
 }
 function iterateInVisualOrder(adapter) {
   const result = [];
-  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (activity) => {
     result.push(activity);
-    const childIds = getChildrenInVisualOrder(
-      String(activity.id),
-      adapter,
-      pinIndex
-    );
+    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, pinIndex);
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
   for (const rootId of rootIds) {
     const root = adapter.getActivity(rootId);
     if (root) visit(root);
@@ -1140,9 +910,8 @@ function setHas(set, id) {
 // src/dispatch/shared/collect-branch-order.ts
 function collectBranchOrder(adapter) {
   const branches = [];
-  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (parentId) => {
-    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
     if (childIds.length > 1) {
       branches.push({ parentId, childIds });
     }
@@ -1155,9 +924,8 @@ function collectBranchOrder(adapter) {
 }
 function collectBranchOrderForParents(adapter, parentIds) {
   const branches = [];
-  const pinIndex = buildRelativePlacementPinIndex(adapter);
   for (const parentId of parentIds) {
-    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
     if (childIds.length > 1) branches.push({ parentId, childIds });
   }
   return branches;
@@ -1190,107 +958,61 @@ function dispatchSortSet(action, deps) {
   return { ok: true, changes };
 }
 
-// src/columns/text/constants.ts
-var TEXT = "text";
-
-// src/columns/description/constants.ts
-var DESCRIPTION = "description";
-
-// src/columns/duration/constants.ts
-var DURATION = "duration";
-
-// src/columns/progress/constants.ts
-var PROGRESS = "progress";
-
-// src/columns/cost/constants.ts
-var COST = "cost";
-
-// src/columns/used-cost/constants.ts
-var USED_COST = "used_cost";
-
-// src/columns/hh-work-time/constants.ts
-var HH_WORK_TIME = "hhWorkTime";
-
-// src/columns/start-date/constants.ts
-var START_DATE = "start_date";
-
-// src/columns/end-date/constants.ts
-var END_DATE = "end_date";
-
-// src/columns/constraint-type/constants.ts
-var CONSTRAINT_TYPE = "constraint_type";
-
-// src/columns/constraint-date/constants.ts
-var CONSTRAINT_DATE = "constraint_date";
-
-// src/columns/calendar-id/constants.ts
-var CALENDAR_ID = "calendar_id";
-
-// src/columns/custom-id/constants.ts
-var CUSTOM_ID = "custom_id";
-
-// src/columns/subcontract-id/constants.ts
-var SUBCONTRACT_ID = "subcontractId";
-
-// src/columns/responsables/constants.ts
-var RESPONSABLES = "responsables";
-
-// src/columns/tags/constants.ts
-var TAGS = "tags";
-
-// src/columns/predecessors/constants.ts
-var CUSTOM_PREDECESSORS = "custom_predecessors";
-
-// src/columns/successors/constants.ts
-var CUSTOM_SUCESSORS = "custom_sucessors";
-
-// src/columns/real-work/constants.ts
-var REAL_WORK = "real_work";
-
-// src/columns/real-cost/constants.ts
-var REAL_COST = "real_cost";
-
-// src/columns/expected-progress/constants.ts
-var EXPECTED_PROGRESS = "expected_progress";
-
-// src/columns/expected-progress-base/constants.ts
-var EXPECTED_PROGRESS_BASE = "expected_progress_base";
-
-// src/columns/start-base/constants.ts
-var START_BASE = "start_base";
-
-// src/columns/end-base/constants.ts
-var END_BASE = "end_base";
-
-// src/columns/duration-base/constants.ts
-var DURATION_BASE = "duration_base";
-
-// src/columns/cost-base/constants.ts
-var COST_BASE = "cost_base";
-
-// src/columns/work-base/constants.ts
-var WORK_BASE = "work_base";
-
-// src/columns/calendar-duration/constants.ts
-var CALENDAR_DURATION = "calendarDuration";
-
-// src/columns/critical-path/constants.ts
-var IS_CRITICAL = "is_critical";
-var EARLY_START = "earlyStart";
-var EARLY_FINISH = "earlyFinish";
-var LATE_START = "lateStart";
-var LATE_FINISH = "lateFinish";
-var FREE_SLACK = "freeSlack";
-var TOTAL_SLACK = "totalSlack";
-
-// src/columns/correlative-id/constants.ts
-var CORRELATIVE_ID = "correlative_id";
+// src/constants/columns.ts
+var EDITABLE = {
+  TEXT: "text",
+  DESCRIPTION: "description",
+  DURATION: "duration",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "used_cost",
+  HH_WORK_TIME: "hhWorkTime",
+  START_DATE: "start_date",
+  END_DATE: "end_date",
+  CONSTRAINT_TYPE: "constraint_type",
+  CONSTRAINT_DATE: "constraint_date",
+  CALENDAR_ID: "calendar_id",
+  CUSTOM_ID: "custom_id",
+  SUBCONTRACT_ID: "subcontractId",
+  RESPONSABLES: "responsables",
+  TAGS: "tags",
+  CUSTOM_PREDECESSORS: "custom_predecessors",
+  CUSTOM_SUCESSORS: "custom_sucessors"
+};
+var READ_ONLY = {
+  REAL_WORK: "real_work",
+  REAL_COST: "real_cost",
+  EXPECTED_PROGRESS: "expected_progress",
+  EXPECTED_PROGRESS_BASE: "expected_progress_base",
+  START_BASE: "start_base",
+  END_BASE: "end_base",
+  DURATION_BASE: "duration_base",
+  COST_BASE: "cost_base",
+  WORK_BASE: "work_base",
+  CALENDAR_DURATION: "calendarDuration",
+  IS_CRITICAL: "is_critical",
+  EARLY_START: "earlyStart",
+  EARLY_FINISH: "earlyFinish",
+  LATE_START: "lateStart",
+  LATE_FINISH: "lateFinish",
+  FREE_SLACK: "freeSlack",
+  TOTAL_SLACK: "totalSlack",
+  CORRELATIVE_ID: "correlative_id",
+  UNIQUE_CORRELATIVE_ID: "unique_correlative_id",
+  PONDERATOR: "ponderator",
+  STATUS: "status"
+};
+var COLUMN = { ...EDITABLE, ...READ_ONLY };
 
-// src/columns/unique-correlative-id/constants.ts
-var UNIQUE_CORRELATIVE_ID = "unique_correlative_id";
+// src/shared/assert-never.ts
+function assertNever(value, message) {
+  throw new Error(message);
+}
 
-// src/columns/ponderator/constants.ts
-var PONDERATOR = "ponderator";
+// src/autoscheduler/utils/cancellation.ts
+function createIsCurrent(id, getCurrentId) {
+  return () => getCurrentId() === id;
+}
 
 // src/types.ts
 var WORK_TIME_DIRECTION = {
@@ -1309,71 +1031,8 @@ var STATUS = {
   DOING: "Doing"
 };
 
-// src/columns/status/constants.ts
-var STATUS_COLUMN = "status";
-var DEFAULT_STATUS_CRITERIA = "Baseline";
-function resolveStatusCriteria(value) {
-  return value === "Actual" ? "Actual" : DEFAULT_STATUS_CRITERIA;
-}
-
-// src/constants/columns.ts
-var EDITABLE = {
-  TEXT,
-  DESCRIPTION,
-  DURATION,
-  PROGRESS,
-  COST,
-  USED_COST,
-  HH_WORK_TIME,
-  START_DATE,
-  END_DATE,
-  CONSTRAINT_TYPE,
-  CONSTRAINT_DATE,
-  CALENDAR_ID,
-  CUSTOM_ID,
-  SUBCONTRACT_ID,
-  RESPONSABLES,
-  TAGS,
-  CUSTOM_PREDECESSORS,
-  CUSTOM_SUCESSORS
-};
-var READ_ONLY = {
-  REAL_WORK,
-  REAL_COST,
-  EXPECTED_PROGRESS,
-  EXPECTED_PROGRESS_BASE,
-  START_BASE,
-  END_BASE,
-  DURATION_BASE,
-  COST_BASE,
-  WORK_BASE,
-  CALENDAR_DURATION,
-  IS_CRITICAL,
-  EARLY_START,
-  EARLY_FINISH,
-  LATE_START,
-  LATE_FINISH,
-  FREE_SLACK,
-  TOTAL_SLACK,
-  CORRELATIVE_ID,
-  UNIQUE_CORRELATIVE_ID,
-  PONDERATOR,
-  STATUS: STATUS_COLUMN
-};
-var COLUMN = { ...EDITABLE, ...READ_ONLY };
-
-// src/shared/assert-never.ts
-function assertNever(value, message) {
-  throw new Error(message);
-}
-
-// src/autoscheduler/utils/cancellation.ts
-function createIsCurrent(id, getCurrentId) {
-  return () => getCurrentId() === id;
-}
-
 // src/constraints/index.ts
-var CONSTRAINT_TYPE2 = {
+var CONSTRAINT_TYPE = {
   ASAP: "asap",
   ALAP: "alap",
   SNET: "snet",
@@ -2290,7 +1949,7 @@ function processConstraints(activityIds, adapter, plans) {
     const activity = adapter.getActivity(id);
     if (!activity) continue;
     const type = activity.constraintType;
-    if (!type || type === CONSTRAINT_TYPE2.ASAP || type === CONSTRAINT_TYPE2.ALAP) {
+    if (!type || type === CONSTRAINT_TYPE.ASAP || type === CONSTRAINT_TYPE.ALAP) {
       continue;
     }
     const bounds = computeConstraintBounds(activity, adapter);
@@ -2339,14 +1998,14 @@ function validateMilestoneConstraint(activity, successorStart) {
   const { constraintType, constraintDate } = activity;
   if (!constraintType || !constraintDate) return successorStart;
   switch (constraintType) {
-    case CONSTRAINT_TYPE2.MSO:
-    case CONSTRAINT_TYPE2.MFO:
+    case CONSTRAINT_TYPE.MSO:
+    case CONSTRAINT_TYPE.MFO:
       return new Date(constraintDate);
-    case CONSTRAINT_TYPE2.SNET:
-    case CONSTRAINT_TYPE2.FNET:
+    case CONSTRAINT_TYPE.SNET:
+    case CONSTRAINT_TYPE.FNET:
       return constraintDate > successorStart ? new Date(constraintDate) : successorStart;
-    case CONSTRAINT_TYPE2.SNLT:
-    case CONSTRAINT_TYPE2.FNLT:
+    case CONSTRAINT_TYPE.SNLT:
+    case CONSTRAINT_TYPE.FNLT:
       return constraintDate < successorStart ? new Date(constraintDate) : successorStart;
     default:
       return successorStart;
@@ -2475,7 +2134,7 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
       });
       plan.earliestSchedulingStart = linkStart;
       plan.earliestSchedulingEnd = plan.endDate;
-    } else if (activity.constraintType === CONSTRAINT_TYPE2.MSO) {
+    } else if (activity.constraintType === CONSTRAINT_TYPE.MSO) {
       if (plan.earliestStart) {
         plan.startDate = plan.earliestStart;
         plan.endDate = plan.earliestEnd ?? adapter.calculateEndDate({
@@ -2484,7 +2143,7 @@ async function asapPass(orderedIds, links, adapter, options, isCurrent, plans) {
           task: activity
         });
       }
-    } else if (activity.constraintType === CONSTRAINT_TYPE2.MFO) {
+    } else if (activity.constraintType === CONSTRAINT_TYPE.MFO) {
       if (plan.latestStart) {
         plan.startDate = plan.latestStart;
         plan.endDate = plan.latestEnd ?? adapter.calculateEndDate({
@@ -2510,7 +2169,7 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
   const activityCount = allActivities.length;
   const alapActivityIds = [];
   for (const activity of allActivities) {
-    if (activity.constraintType === CONSTRAINT_TYPE2.ALAP) {
+    if (activity.constraintType === CONSTRAINT_TYPE.ALAP) {
       alapActivityIds.push(activity.id);
     }
   }
@@ -2557,7 +2216,7 @@ async function alapPass(reversedIds, links, asapPlans, adapter, _options, isCurr
     sliceStart = yieldResult.newSliceStart;
     const activity = adapter.getActivity(activityId);
     if (!activity) continue;
-    if (activity.constraintType !== CONSTRAINT_TYPE2.ALAP) continue;
+    if (activity.constraintType !== CONSTRAINT_TYPE.ALAP) continue;
     if (!activity.autoScheduling) continue;
     if (activity.progress === COMPLETED_PROGRESS) continue;
     if (isSummary(activity.type, adapter.getChildren(activityId).length > 0))
@@ -3066,9 +2725,7 @@ function applyLinkCreates(links, deps) {
       break;
     }
     duplicateKeys.set(key, linkId);
-    if (existingGraphHasCycle && // ponytail: preserve legacy sequential semantics; optimize with dynamic
-    // SCC reachability only if corrupt cyclic schedules become measurable.
-    wouldIntroduceCycle(edges, {
+    if (existingGraphHasCycle && wouldIntroduceCycle(edges, {
       source: operation.source,
       target: operation.target
     })) {
@@ -3546,7 +3203,7 @@ function widenScopeToAlapActivities(group, allLinks, adapter) {
   const widenedAlapKeys = /* @__PURE__ */ new Set();
   for (const activity of adapter.getAllActivities()) {
     const activityKey = String(activity.id);
-    const isOutOfComponentAlap = activity.constraintType === CONSTRAINT_TYPE2.ALAP && !idSet.has(activityKey);
+    const isOutOfComponentAlap = activity.constraintType === CONSTRAINT_TYPE.ALAP && !idSet.has(activityKey);
     if (!isOutOfComponentAlap) continue;
     widenedAlapKeys.add(activityKey);
     idSet.add(activityKey);
@@ -3632,6 +3289,84 @@ function roundProgressPerLevel(value) {
   return Number(value.toFixed(2));
 }
 
+// src/propagations/upward/progress-rollup.ts
+function recomputeAllProgressRollup(adapter) {
+  for (const parentId of parentsDeepestFirst(adapter)) {
+    rollupParent(parentId, adapter);
+  }
+}
+function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
+  for (const parentId of parentIdsDeepestFirst) {
+    rollupParent(parentId, adapter);
+  }
+}
+function parentsDeepestFirst(adapter) {
+  const parents = /* @__PURE__ */ new Set();
+  adapter.forEachActivity((_activity, id) => {
+    if (adapter.getChildren(id).length > 0) parents.add(id);
+  });
+  const depthById = /* @__PURE__ */ new Map();
+  for (const id of parents) depthById.set(id, depthOf(id, adapter));
+  return [...parents].sort(
+    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
+  );
+}
+function depthOf(id, adapter) {
+  let depth = 0;
+  let current = id;
+  while (current && current !== "0") {
+    if (!adapter.getActivity(current)) break;
+    depth += 1;
+    current = adapter.getParentId(current);
+  }
+  return depth;
+}
+function rollupParent(parentId, adapter) {
+  const childIds = adapter.getChildren(parentId);
+  if (childIds.length === 0) return;
+  const children = [];
+  for (const childId of childIds) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    children.push({
+      progress: Number(child.progress ?? 0),
+      ponderator: Number(child.ponderator ?? 0)
+    });
+  }
+  applyWeightedProgressRollup(parentId, children, adapter);
+}
+function applyWeightedProgressRollup(parentId, children, adapter) {
+  const parent = adapter.getActivity(parentId);
+  if (!parent) return;
+  const rollup = computeWeightedProgressRollup(children);
+  if (rollup === null) {
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback !== null) {
+      adapter.setActivityField(parentId, COLUMN.PROGRESS, fallback);
+    }
+    return;
+  }
+  if (adapter.getProgressFallback(parentId) === null) {
+    adapter.setProgressFallback(parentId, Number(parent.progress ?? 0));
+  }
+  adapter.setActivityField(
+    parentId,
+    COLUMN.PROGRESS,
+    roundProgressPerLevel(rollup)
+  );
+}
+function setExplicitSummaryProgressFallbacks(activityId, progress, adapter) {
+  const pending = [activityId];
+  while (pending.length > 0) {
+    const currentId = pending.pop();
+    if (currentId === void 0) continue;
+    const children = adapter.getChildren(currentId);
+    if (children.length === 0) continue;
+    adapter.setProgressFallback(currentId, progress);
+    pending.push(...children);
+  }
+}
+
 // src/columns/real-work/compute.ts
 function computeLeafRealWork(workHours, progress) {
   return (Number(workHours) || 0) * (Number(progress) || 0) / 100;
@@ -3747,16 +3482,8 @@ function recomputeParentFromChildren(parentId, adapter, progressMode = "freeze-w
   adapter.setActivityField(parentId, "startDate", newStart);
   adapter.setActivityField(parentId, "endDate", newEnd);
   adapter.setActivityField(parentId, "durationHours", durationHours);
-  const progressRollup = computeWeightedProgressRollup(
-    aggregate.weightedChildren
-  );
-  const shouldWriteProgress = progressMode !== "skip" && (progressRollup !== null || progressMode === "zero-when-no-contribution");
-  if (shouldWriteProgress) {
-    adapter.setActivityField(
-      parentId,
-      "progress",
-      roundProgressPerLevel(progressRollup ?? 0)
-    );
+  if (progressMode !== "skip") {
+    applyWeightedProgressRollup(parentId, aggregate.weightedChildren, adapter);
   }
   if (recomputeRealWork) {
     adapter.setActivityField(parentId, "realWorkHours", aggregate.realWorkSum);
@@ -3779,10 +3506,10 @@ function collectParentIds(adapter) {
 }
 function computeDepths(ids, adapter) {
   const depths = /* @__PURE__ */ new Map();
-  for (const id of ids) depths.set(id, depthOf(id, adapter));
+  for (const id of ids) depths.set(id, depthOf2(id, adapter));
   return depths;
 }
-function depthOf(id, adapter) {
+function depthOf2(id, adapter) {
   let depth = 0;
   let current = id;
   while (current && !isRootParent(current)) {
@@ -3908,7 +3635,7 @@ var descriptionPipeline = {
 
 // src/columns/shared/activity-predicates.ts
 function effectiveConstraintType(activity) {
-  return activity.constraintType ?? CONSTRAINT_TYPE2.ASAP;
+  return activity.constraintType ?? CONSTRAINT_TYPE.ASAP;
 }
 var PROGRESS_COMPLETE = COMPLETED_PROGRESS;
 function isCompletedActivity(activity) {
@@ -4265,6 +3992,7 @@ function buildAncestorRollupCascade(activity, newValue, hierarchy) {
   const mutations = [];
   for (const id of chain) {
     const rollup = computeWeightedProgress(id, overlay, hierarchy);
+    if (rollup === null) continue;
     overlay.set(id, rollup);
     mutations.push({
       activityId: id,
@@ -4278,7 +4006,8 @@ function computeWeightedProgress(parentId, overlay, hierarchy) {
     progress: overlay.has(child.id) ? overlay.get(child.id) : child.progress,
     ponderator: child.ponderator ?? 0
   }));
-  return Number((computeWeightedProgressRollup(children) ?? 0).toFixed(2));
+  const rollup = computeWeightedProgressRollup(children);
+  return rollup === null ? null : Number(rollup.toFixed(2));
 }
 function buildRecursiveTrackingEvents(activity, newValue) {
   return [
@@ -4646,7 +4375,7 @@ function checkIsWorkingDay(newDate, activity, ctx) {
   return null;
 }
 function detectEndDateConstraintWarning(activity, newEndDate) {
-  const cannotViolateStartPin = effectiveConstraintType(activity) === CONSTRAINT_TYPE2.MSO;
+  const cannotViolateStartPin = effectiveConstraintType(activity) === CONSTRAINT_TYPE.MSO;
   if (cannotViolateStartPin) return void 0;
   const projectedDate = pickProjectedDateForConstraint(
     effectiveConstraintType(activity),
@@ -4696,7 +4425,7 @@ function calculateNewDuration(activity, newEndDate, ctx) {
 
 // src/columns/constraint-type/constraint-type-pipeline.ts
 var VALID_CONSTRAINT_TYPES = new Set(
-  Object.values(CONSTRAINT_TYPE2)
+  Object.values(CONSTRAINT_TYPE)
 );
 var constraintTypePipeline = {
   targetField: "constraintType",
@@ -5477,6 +5206,12 @@ function runExpectedProgressBase(state, now, defaultBaseCalendarId = null) {
   return computeExpectedProgress(rootIds, now, adapter, defaultBaseCalendarId);
 }
 
+// src/columns/status/constants.ts
+var DEFAULT_STATUS_CRITERIA = "Baseline";
+function resolveStatusCriteria(value) {
+  return value === "Actual" ? "Actual" : DEFAULT_STATUS_CRITERIA;
+}
+
 // src/columns/status/compute.ts
 var roundToTwoDecimals = (value) => Math.round(value * 100) / 100;
 function resolveExpectedForStatus(activity, criteria) {
@@ -5504,7 +5239,7 @@ function applyStatusPass(state, criteria) {
       resolveExpectedForStatus(activity, criteria)
     );
     if (activity.status !== status) {
-      setActivityFieldDynamic(state, id, STATUS_COLUMN, status);
+      setActivityFieldDynamic(state, id, COLUMN.STATUS, status);
       changed.push(id);
     }
   });
@@ -9277,10 +9012,10 @@ var FreeFloat = class {
     this.durationCache = /* @__PURE__ */ new Map();
   }
   getFreeFloat() {
-    const PROGRESS2 = Number(this.activity.progress);
+    const PROGRESS = Number(this.activity.progress);
     const CONSTRAINT = this.getConstraintType();
     this.calculateFreeFloatOfLink(CONSTRAINT);
-    const activityFreeFloat = PROGRESS2 === 100 ? 0 : this.getFreeFloatBaseConstraint(CONSTRAINT);
+    const activityFreeFloat = PROGRESS === 100 ? 0 : this.getFreeFloatBaseConstraint(CONSTRAINT);
     return {
       activityFreeFloat,
       linksFreeFloat: this.linksFreeFloatObject
@@ -9439,11 +9174,11 @@ var FreeFloat = class {
     };
   }
   calculateMsoMfo(constraint) {
-    const CONSTRAINT_DATE2 = this.activity.constraint_date || /* @__PURE__ */ new Date();
+    const CONSTRAINT_DATE = this.activity.constraint_date || /* @__PURE__ */ new Date();
     const calculation = this.forwardMap.get(this.activity.id);
     const DATE_TO_CALCULATE = constraint === CONSTRAINT_TYPES.MSO ? calculation?.es : calculation?.ef;
     const freeSlack = this.calculationWithCalendar(
-      CONSTRAINT_DATE2,
+      CONSTRAINT_DATE,
       DATE_TO_CALCULATE
     );
     return Math.max(0, this.parseHoursToDays(freeSlack));
@@ -10223,24 +9958,82 @@ function resolveDerivedPasses(action, autoSchedule, options) {
 
 // src/dispatch/shared/post-mutation.ts
 async function runPostMutation(deps, args) {
-  const passes = resolvePasses(args);
+  const progressInvalidation = resolveProgressInvalidation(deps.adapter);
+  const passes = resolvePasses(args, progressInvalidation);
   if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
     await refreshMutatedParentBounds(deps.adapter, args);
   }
   const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(deps, args.autoscheduleFrom) : emptySchedule();
-  await rollUpParentBounds(deps.adapter, args, schedule.scheduledIds, passes);
+  await rollUpParentBounds(
+    deps.adapter,
+    args,
+    schedule.scheduledIds,
+    passes,
+    progressInvalidation
+  );
   await runDerivedRecomputes(deps, passes, args.now);
   return schedule;
 }
-function resolvePasses(args) {
+function resolvePasses(args, progressInvalidation) {
   const requested = args.autoscheduleFrom !== null;
   const ran = !args.options.skipAutoSchedule && requested;
   const passes = new Set(
     resolveDerivedPasses(args.action, { ran }, args.options)
   );
-  if (args.recomputeParentProgress) passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  if (args.recomputeParentProgress || progressInvalidation.affectedParents.size > 0) {
+    passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  }
   return passes;
 }
+function resolveProgressInvalidation(adapter) {
+  const affectedParents = /* @__PURE__ */ new Set();
+  const dirtySeeds = /* @__PURE__ */ new Set();
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return { affectedParents, dirtySeeds };
+  const affectParent = (parentId) => {
+    if (parentId === null || isRootParent(parentId)) return;
+    const normalized2 = String(parentId);
+    affectedParents.add(normalized2);
+    const childId = adapter.getChildren(normalized2)[0];
+    if (childId !== void 0) dirtySeeds.add(childId);
+  };
+  collectStructuralProgressInvalidations(adapter, journal.ops, affectParent);
+  collectFieldProgressInvalidations(
+    adapter,
+    journal.before,
+    dirtySeeds,
+    affectParent
+  );
+  return { affectedParents, dirtySeeds };
+}
+function collectStructuralProgressInvalidations(adapter, operations, affectParent) {
+  for (const operation of operations) {
+    if (operation.kind === "insert") {
+      const inserted = adapter.getActivity(operation.activityId);
+      if (inserted) affectParent(inserted.parentId);
+    } else if (operation.kind === "remove") {
+      affectParent(operation.before.parentId);
+    }
+  }
+}
+function collectFieldProgressInvalidations(adapter, beforeById, dirtySeeds, affectParent) {
+  for (const [activityId, before] of beforeById) {
+    const after = adapter.getActivity(activityId);
+    if (!after) continue;
+    const progressChanged = !Object.is(before.progress, after.progress);
+    const ponderatorChanged = !Object.is(before.ponderator, after.ponderator);
+    const parentChanged = !Object.is(before.parentId, after.parentId);
+    if (progressChanged || ponderatorChanged) {
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+    if (parentChanged) {
+      affectParent(before.parentId);
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+  }
+}
 async function runAutoschedule(deps, autoscheduleFrom) {
   const options = autoscheduleFrom === "roots" ? {} : { triggerId: autoscheduleFrom };
   const result = await deps.scheduler.schedule(options);
@@ -10268,18 +10061,36 @@ async function refreshMutatedParentBounds(adapter, args) {
   if (mutated.size === 0) return;
   await updateParentBoundsFromChildren(adapter, mutated, false);
 }
-async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
+async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressInvalidation) {
+  if (passes.has(DERIVED_PASS.PARENT_PROGRESS)) {
+    restoreDemotedProgressFallbacks(
+      adapter,
+      progressInvalidation.affectedParents
+    );
+  }
   const dirty = args.collectDirty ? args.collectDirty(scheduledIds) : collectDirtyForStructural(args.recomputeParentsFrom, scheduledIds);
+  for (const activityId of progressInvalidation.dirtySeeds) {
+    dirty.add(activityId);
+  }
   await updateParentBoundsFromChildren(
     adapter,
     dirty,
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
       recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
-      progressMode: args.recomputeParentProgress ? "zero-when-no-contribution" : "freeze-when-no-contribution"
+      progressMode: "freeze-when-no-contribution"
     }
   );
 }
+function restoreDemotedProgressFallbacks(adapter, affectedParents) {
+  for (const parentId of affectedParents) {
+    if (adapter.hasChildren(parentId)) continue;
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback === null) continue;
+    adapter.setActivityField(parentId, "progress", fallback);
+    adapter.setProgressFallback(parentId, null);
+  }
+}
 async function runDerivedRecomputes(deps, passes, now) {
   if (passes.has(DERIVED_PASS.EXPECTED_PROGRESS) && now !== null) {
     if (hasActiveBaseline(deps.adapter)) {
@@ -11506,9 +11317,8 @@ function buildParentMutations(input) {
   if (wasPromotableLeaf) {
     fields.type = PROMOTION_TARGET_TYPE;
     if ((input.promotionSource ?? "create") === "create") {
-      fields.constraintType = CONSTRAINT_TYPE2.ASAP;
+      fields.constraintType = CONSTRAINT_TYPE.ASAP;
       fields.constraintDate = null;
-      fields.progress = 0;
     }
   }
   return {
@@ -12647,8 +12457,6 @@ function dispatchSirSync(action, deps) {
     id,
     kind: "updated",
     fields: { pendingRequestIds: { before, after } },
-    // ISSUE-025: `after` must be the COMPLETE post-change entity; a partial
-    // object crashes any consumer that projects the full snapshot.
     after: structuredCloneActivity(updated)
   };
   return {
@@ -12663,60 +12471,6 @@ function dispatchSirSync(action, deps) {
   };
 }
 
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
-  }
-}
-function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
-  for (const parentId of parentIdsDeepestFirst) {
-    rollupParent(parentId, adapter);
-  }
-}
-function parentsDeepestFirst(adapter) {
-  const parents = /* @__PURE__ */ new Set();
-  adapter.forEachActivity((_activity, id) => {
-    if (adapter.getChildren(id).length > 0) parents.add(id);
-  });
-  const depthById = /* @__PURE__ */ new Map();
-  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
-  return [...parents].sort(
-    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
-  );
-}
-function depthOf2(id, adapter) {
-  let depth = 0;
-  let current = id;
-  while (current && current !== "0") {
-    if (!adapter.getActivity(current)) break;
-    depth += 1;
-    current = adapter.getParentId(current);
-  }
-  return depth;
-}
-function rollupParent(parentId, adapter) {
-  const childIds = adapter.getChildren(parentId);
-  if (childIds.length === 0) return;
-  const children = [];
-  for (const childId of childIds) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    children.push({
-      progress: Number(child.progress ?? 0),
-      ponderator: Number(child.ponderator ?? 0)
-    });
-  }
-  const rollup = computeWeightedProgressRollup(children);
-  if (rollup !== null) {
-    adapter.setActivityField(
-      parentId,
-      COLUMN.PROGRESS,
-      roundProgressPerLevel(rollup)
-    );
-  }
-}
-
 // src/dispatch/handlers/persistence-acknowledge.ts
 function persistedOwnersOf(entities) {
   const owners = /* @__PURE__ */ new Map();
@@ -13783,6 +13537,11 @@ async function dispatchActivitySetProgress(action, options, deps) {
   const touchedIds = collectTouchedIds(action.activityId, changes);
   const beforeSnap = await snapshotActivities(adapter, touchedIds);
   applyFieldChanges(adapter, action.activityId, changes);
+  setExplicitSummaryProgressFallbacks(
+    action.activityId,
+    action.newValue,
+    adapter
+  );
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
@@ -17646,7 +17405,8 @@ var WriteCapture = class {
       ops: [],
       linkFieldCaptured: /* @__PURE__ */ new Set(),
       correlativeBefore: /* @__PURE__ */ new Map(),
-      scheduledBefore: /* @__PURE__ */ new Map()
+      scheduledBefore: /* @__PURE__ */ new Map(),
+      progressFallbackBefore: /* @__PURE__ */ new Map()
     };
   }
   peek() {
@@ -17709,6 +17469,11 @@ var WriteCapture = class {
       before: cloneLink(current)
     });
   }
+  noteProgressFallback(activityId, current) {
+    const journal = this._journal;
+    if (!journal || journal.progressFallbackBefore.has(activityId)) return;
+    journal.progressFallbackBefore.set(activityId, current);
+  }
 };
 function cloneLink(link) {
   return { ...link };
@@ -17878,11 +17643,83 @@ var HierarchyIndex = class {
   }
 };
 
+// src/internal/state/view-state.ts
+var ViewStateStore = class {
+  checkedSet = /* @__PURE__ */ new Set();
+  hiddenSet = /* @__PURE__ */ new Set();
+  activeFilter = null;
+  activeOrder = null;
+  isChecked(activityId) {
+    return this.checkedSet.has(activityId);
+  }
+  isVisible(activityId) {
+    return !this.hiddenSet.has(activityId);
+  }
+  hiddenIds() {
+    return [...this.hiddenSet];
+  }
+  getActiveFilter() {
+    return this.activeFilter;
+  }
+  setActiveFilter(nextFilter) {
+    this.activeFilter = nextFilter;
+  }
+  getActiveOrder() {
+    return this.activeOrder;
+  }
+  setActiveOrder(nextOrder) {
+    this.activeOrder = nextOrder;
+  }
+  checkedIds() {
+    return [...this.checkedSet];
+  }
+  checkedCount() {
+    return this.checkedSet.size;
+  }
+  setChecked(activityId, nextChecked) {
+    if (nextChecked === this.checkedSet.has(activityId)) return false;
+    if (nextChecked) this.checkedSet.add(activityId);
+    else this.checkedSet.delete(activityId);
+    return true;
+  }
+  setVisible(activityId, nextVisible) {
+    if (nextVisible === !this.hiddenSet.has(activityId)) return false;
+    if (nextVisible) this.hiddenSet.delete(activityId);
+    else this.hiddenSet.add(activityId);
+    return true;
+  }
+  forget(activityId) {
+    this.checkedSet.delete(activityId);
+    this.hiddenSet.delete(activityId);
+  }
+  hydrate(seed2) {
+    this.checkedSet = new Set(seed2.checkedIds ?? []);
+    this.hiddenSet = new Set(seed2.hiddenIds ?? []);
+    this.activeFilter = null;
+    this.activeOrder = null;
+  }
+  snapshot() {
+    return {
+      checked: new Set(this.checkedSet),
+      hidden: new Set(this.hiddenSet),
+      activeFilter: this.activeFilter,
+      activeOrder: this.activeOrder
+    };
+  }
+  restore(snapshot) {
+    this.checkedSet = new Set(snapshot.checked);
+    this.hiddenSet = new Set(snapshot.hidden);
+    this.activeFilter = snapshot.activeFilter;
+    this.activeOrder = snapshot.activeOrder;
+  }
+};
+
 // src/internal/state/schedule-state.ts
 var ScheduleState = class _ScheduleState {
   _activities = /* @__PURE__ */ new Map();
   _lastStartDate = /* @__PURE__ */ new Map();
   _promotionSnapshot = /* @__PURE__ */ new Map();
+  _progressFallback = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
@@ -17943,6 +17780,7 @@ var ScheduleState = class _ScheduleState {
         cloneDomainValue(snapshot)
       ])
     );
+    fork._progressFallback = new Map(this._progressFallback);
     fork._flags = cloneDomainValue(this._flags);
     fork._filterProjection = cloneDomainValue(this._filterProjection);
     return fork;
@@ -17996,6 +17834,17 @@ var ScheduleState = class _ScheduleState {
     this._capturePromotionSnapshotOnce();
     this._promotionSnapshot.set(String(activityId), snapshot);
   }
+  getProgressFallback(activityId) {
+    return this._progressFallback.get(String(activityId)) ?? null;
+  }
+  setProgressFallback(activityId, value) {
+    const key = String(activityId);
+    const current = this._progressFallback.get(key) ?? null;
+    if (Object.is(current, value)) return;
+    this._writeCapture.noteProgressFallback(key, current);
+    if (value === null) this._progressFallback.delete(key);
+    else this._progressFallback.set(key, value);
+  }
   _capturePromotionSnapshotOnce() {
     if (this._writeCapture.peek() === null) return;
     if (this._promotionSnapshotBefore === null) {
@@ -18056,28 +17905,6 @@ var ScheduleState = class _ScheduleState {
     this._viewState.setActiveOrder(nextOrder);
     this.invalidateDerivedOrder();
   }
-  setRelativePlacementPin(activityId, pin) {
-    this._viewState.setRelativePlacementPin(String(activityId), pin);
-    this.invalidateVisualOrderIds();
-  }
-  getRelativePlacementPins() {
-    return this._viewState.getRelativePlacementPins();
-  }
-  restoreRelativePlacementPins(pins) {
-    this._viewState.restoreRelativePlacementPins(pins);
-    this._filterProjection = null;
-    this.invalidateVisualOrderIds();
-  }
-  /**
-   * Rebuild-on-demand, memoized: at most one build per invalidation, never one
-   * per comparison. getChildrenInVisualOrder asks for this once and then sorts a
-   * 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) {
@@ -18088,12 +17915,6 @@ var ScheduleState = class _ScheduleState {
     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;
@@ -18274,11 +18095,8 @@ var ScheduleState = class _ScheduleState {
     const activity = this.getActivity(activityId);
     if (activity) this._writeCapture.noteRemove(String(activityId), activity);
     const key = String(activityId);
-    const relativePlacementPins = this._viewState.getRelativePlacementPins();
-    const hasDependentPin = [...relativePlacementPins.values()].some(
-      ({ referenceId }) => referenceId === key
-    );
-    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key) || relativePlacementPins.has(key) || hasDependentPin) {
+    this.setProgressFallback(key, null);
+    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key)) {
       this._captureViewStateOnce();
     }
     this._viewState.forget(key);
@@ -18302,7 +18120,13 @@ var ScheduleState = class _ScheduleState {
   restoreFromCapture() {
     const journal = this._writeCapture.peek();
     if (!journal) return;
-    const { ops, before, correlativeBefore, scheduledBefore } = journal;
+    const {
+      ops,
+      before,
+      correlativeBefore,
+      scheduledBefore,
+      progressFallbackBefore
+    } = journal;
     this._undoLinkAdds(ops);
     this._undoInserts(ops);
     this._reInsertRemovedActivities(ops);
@@ -18311,6 +18135,7 @@ var ScheduleState = class _ScheduleState {
     this._restoreCorrelatives(correlativeBefore);
     this._restoreActivityFields(scheduledBefore);
     this._restoreActivityFields(before);
+    this._restoreProgressFallbacks(progressFallbackBefore);
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
       this._filterProjection = null;
@@ -18326,6 +18151,12 @@ var ScheduleState = class _ScheduleState {
     this._cache.visualOrderIds = null;
     this._hierarchy.markDirty();
   }
+  _restoreProgressFallbacks(before) {
+    for (const [activityId, value] of before) {
+      if (value === null) this._progressFallback.delete(activityId);
+      else this._progressFallback.set(activityId, value);
+    }
+  }
   _restoreCorrelatives(correlativeBefore) {
     for (const [id, before] of correlativeBefore) {
       const live = this._activities.get(id);
@@ -18539,15 +18370,15 @@ function buildHistoryChangeSet(changes) {
     links: linksWithoutAfter
   });
 }
-function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, relativePlacementPinsBefore, relativePlacementPinsAfter) {
+function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, progressFallbackBefore, progressFallbackAfter) {
   return {
     changeSet,
     beforeSnap,
     beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
     afterSnap,
     afterLinks: resetDerivedLinkSnapshots(afterLinks),
-    relativePlacementPinsBefore,
-    relativePlacementPinsAfter
+    progressFallbackBefore,
+    progressFallbackAfter
   };
 }
 function resetDerivedLinkSnapshots(snapshots) {
@@ -18850,8 +18681,10 @@ function applyChangeSetSide(state, entry, side) {
       );
     }
   }
-  const pins = side === "before" ? entry.relativePlacementPinsBefore : entry.relativePlacementPinsAfter;
-  if (pins !== void 0) state.restoreRelativePlacementPins(pins);
+  const progressFallbacks = side === "before" ? entry.progressFallbackBefore : entry.progressFallbackAfter;
+  for (const [activityId, value] of progressFallbacks ?? []) {
+    state.setProgressFallback(activityId, value);
+  }
 }
 
 // src/dispatch/undo/undo-recorder.ts
@@ -20743,6 +20576,7 @@ async function runInitialPasses(deps) {
   normalizeLoadedConstraintDates(state);
   recomputeCanonicalRealWork(state);
   if (skipAutoSchedule) {
+    recomputeAllProgressRollup(state);
     if (now) {
       applyExpectedProgressLive(state, now);
       applyStatusPass(state, sector.statusCriteria);
@@ -20754,6 +20588,7 @@ async function runInitialPasses(deps) {
   normalizeMilestoneConstraintDatesForDisplay(state);
   recomputeSkippedLeafEnds(state);
   await updateParentBoundsFromChildren(state, void 0, false);
+  recomputeAllProgressRollup(state);
   if (now) {
     applyExpectedProgressLive(state, now);
     applyStatusPass(state, sector.statusCriteria);
@@ -21196,41 +21031,12 @@ function collectChangedActivities(changes, adapter) {
   }
   return activities;
 }
-function changesAffectRelativePinProjection(changes, changedActivities, adapter, pins) {
-  if (pins.size === 0) return false;
-  if (changes.activities.some(
-    (change) => change.kind === "created" && pins.has(String(change.id))
-  )) {
-    return true;
-  }
-  const referenceIds = new Set(
-    [...pins.values()].map(({ referenceId }) => String(referenceId))
-  );
-  for (const activity of changedActivities) {
-    let activityId = String(activity.id);
-    while (activityId !== null) {
-      if (referenceIds.has(activityId)) return true;
-      activityId = adapter.getParentId(activityId);
-    }
-  }
-  return false;
-}
 function isCurrentFilterProjection(projection, filter, context) {
   if (projection === null || projection.filter !== filter) return false;
   const hasCurrentHours = projection.context.hoursPerDay === context.hoursPerDay;
   const hasCurrentLocale = projection.context.locale === context.locale;
   return hasCurrentHours && hasCurrentLocale;
 }
-function relativePlacementPinsEqual(left, right) {
-  if (left.size !== right.size) return false;
-  for (const [activityId, pin] of left) {
-    const other = right.get(activityId);
-    if (other === void 0 || other.referenceId !== pin.referenceId || other.branchParentId !== pin.branchParentId || other.side !== pin.side) {
-      return false;
-    }
-  }
-  return true;
-}
 var ScheduleCore = class _ScheduleCore {
   _activityClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
@@ -21239,29 +21045,6 @@ var ScheduleCore = class _ScheduleCore {
   _undo = new UndoRecorder();
   _opQueue = Promise.resolve();
   _scheduleRevision = 0;
-  /**
-   * Revision counting mutations that have been ADMITTED, whether or not they
-   * have changed anything yet. `_scheduleRevision` counts the ones that
-   * actually did.
-   *
-   * INVARIANT: `_pendingScheduleRevision >= _scheduleRevision`, and equality
-   * means no mutation is in flight.
-   *
-   * The two exist separately because the useful instant and the knowable
-   * instant are not the same one. A critical-path calculation becomes garbage
-   * the moment the next mutation is admitted, but whether that mutation is
-   * substantive is only knowable once its ChangeSet exists, which is hundreds
-   * of milliseconds later at project scale. Measured live on a 12268-activity
-   * project: the cancellation flag flipped 929 ms into a 930 ms calculation,
-   * 812 into 812 and 785 into 785, because the job's apply block queues behind
-   * the very dispatch whose completion cancels it. Cancellation and job end
-   * were the same event, so every discarded job ran the whole calculation.
-   *
-   * Splitting the counter buys the early signal without moving the meaning of
-   * `_scheduleRevision`, whose three readers (`isCriticalPathSettled`,
-   * `createDateGesturePreview` and the job's own `isCurrent`) are all written
-   * against "the state actually changed".
-   */
   _pendingScheduleRevision = 0;
   _criticalPathRevision = -1;
   _activeCriticalPath = null;
@@ -21374,13 +21157,6 @@ var ScheduleCore = class _ScheduleCore {
     this.assertReady();
     return readAllActivities(this.coreRuntime.state);
   }
-  /**
-   * Read del plan de indent (ISSUE-080): los padres destino DISTINTOS bajo los
-   * que quedarían las actividades si se indentaran ahora. Es exactamente la
-   * planificación que ejecuta el handler (`planIndentMoves`, autoridad única),
-   * expuesta para que la frontera pueda correr el protocolo de conversión a
-   * madre (chequeo backend + modal) ANTES de despachar. Solo lecturas.
-   */
   getIndentTargetParentIds(activityIds) {
     this.assertReady();
     const plan = planIndentMoves(
@@ -21533,7 +21309,6 @@ var ScheduleCore = class _ScheduleCore {
     this.assertReady();
     return this._saveTracker.hasUnsavedChanges();
   }
-  /** Read-only revision; moves once per substantive mutation. */
   getScheduleRevision() {
     return this._scheduleRevision;
   }
@@ -21579,24 +21354,10 @@ var ScheduleCore = class _ScheduleCore {
     );
     return workPromise;
   }
-  /**
-   * Marks a mutation as admitted and invalidates the calculation in flight.
-   *
-   * Called BEFORE `_enqueue`, which is the point of the whole thing: the wait
-   * in the operation queue is part of the window a running calculation wastes,
-   * and it is the longest part of it when several mutations are already
-   * queued.
-   *
-   * `dispatchChangesSchedulingState` is a pure function of the action, so this
-   * decision needs no state and cannot be wrong about the action's nature. What
-   * it cannot know yet is whether the mutation will produce anything, which is
-   * what `_settleScheduleMutation` reconciles afterwards.
-   */
   _beginScheduleMutation(action) {
     if (!dispatchChangesSchedulingState(action)) return false;
     return this._admitScheduleMutation();
   }
-  /** Undo and redo have no action to classify: reaching them IS the mutation. */
   _admitScheduleMutation() {
     this._pendingScheduleRevision++;
     if (this._activeCriticalPath) {
@@ -21604,30 +21365,6 @@ var ScheduleCore = class _ScheduleCore {
     }
     return true;
   }
-  /**
-   * Closes a mutation admitted by `_beginScheduleMutation`, on EVERY exit path.
-   *
-   * `changedState` false means the mutation was admitted and produced nothing
-   * (rejected, non-substantive, or rolled back). The pending revision walks
-   * back so the invariant holds and `isCriticalPathSettled` keeps telling the
-   * truth, and the calculation this mutation killed for nothing is re-armed.
-   *
-   * The re-arm goes through the queue and that is not incidental. Started
-   * outside it, the calculation would run immediately while the next queued
-   * mutation is still waiting, and that mutation would kill it again on
-   * admission: a cancel-and-restart treadmill burning a fresh project-wide deep
-   * copy per lap. Inside the queue the restart cannot happen until the queue
-   * drains, so at most one calculation is armed per settled mutation. The burst
-   * scenario will NOT catch a regression here, because there every dispatch
-   * succeeds and this path is never taken.
-   *
-   * It re-arms through `recomputeCriticalPath` rather than enqueueing the job
-   * directly, because the queue slot must NOT await the job: the job's own
-   * apply block needs a later slot on this same queue, so awaiting it from
-   * inside a slot deadlocks the core. `recomputeCriticalPath` already has the
-   * shape that returns the job's promise out of the slot instead of awaiting
-   * it, and it keeps `_criticalPathReady` pointing at the live calculation.
-   */
   _settleScheduleMutation(admitted, changedState) {
     if (!admitted) return;
     if (changedState) return;
@@ -21678,8 +21415,6 @@ var ScheduleCore = class _ScheduleCore {
       dateFormat: this.coreRuntime.sector.dateFormat
     });
     const historyPolicy = getDispatchHistoryPolicy(action);
-    const capturesRelativePlacementPins = action.kind === "activity-create" || action.kind === "activity-delete" || action.kind === "activity-batch" && action.mode === "replace";
-    const relativePlacementPinsBefore = capturesRelativePlacementPins ? new Map(this.coreRuntime.state.getRelativePlacementPins()) : void 0;
     const generatorSnapshot = [
       this.coreRuntime.activityIdGenerator.snapshot(),
       this.coreRuntime.linkIdGenerator.snapshot(),
@@ -21688,6 +21423,7 @@ var ScheduleCore = class _ScheduleCore {
     this.coreRuntime.state.beginWriteCapture();
     this.coreRuntime.customIdTracker.beginCustomIdTransaction();
     let result;
+    let progressFallbackBefore;
     try {
       result = await performDispatch(action, options, {
         adapter: this.coreRuntime.state,
@@ -21708,6 +21444,10 @@ var ScheduleCore = class _ScheduleCore {
         )?.id ?? null,
         now: this.coreRuntime.clock ? endOfLocalDay(this.coreRuntime.clock()) : null
       });
+      const fallbackBefore = this.coreRuntime.state.peekWriteCapture()?.progressFallbackBefore;
+      if (fallbackBefore && fallbackBefore.size > 0) {
+        progressFallbackBefore = new Map(fallbackBefore);
+      }
       if (!result.ok) this._rollback(generatorSnapshot);
     } catch (error) {
       this._rollback(generatorSnapshot);
@@ -21716,17 +21456,17 @@ var ScheduleCore = class _ScheduleCore {
       this.coreRuntime.state.endWriteCapture();
       this.coreRuntime.customIdTracker.commitCustomIdTransaction();
     }
-    if (result.ok) this._recordRelativePlacementPin(action, result.changes);
     if (result.ok && historyPolicy === "record" && changeSetIsSubstantive(result.changes)) {
       const created = captureCreatedSnapshots(
         this.coreRuntime.state,
         result.changes
       );
-      const relativePlacementPinsAfter = capturesRelativePlacementPins ? new Map(this.coreRuntime.state.getRelativePlacementPins()) : void 0;
-      const relativePlacementPinsChanged = relativePlacementPinsBefore !== void 0 && relativePlacementPinsAfter !== void 0 && !relativePlacementPinsEqual(
-        relativePlacementPinsBefore,
-        relativePlacementPinsAfter
-      );
+      const progressFallbackAfter = progressFallbackBefore ? new Map(
+        Array.from(progressFallbackBefore.keys(), (activityId) => [
+          activityId,
+          this.coreRuntime.state.getProgressFallback(activityId)
+        ])
+      ) : void 0;
       this._undo.record(
         buildUndoEntry(
           buildHistoryChangeSet(result.changes),
@@ -21734,8 +21474,8 @@ var ScheduleCore = class _ScheduleCore {
           result.__beforeLinks,
           created.afterSnap,
           created.afterLinks,
-          relativePlacementPinsChanged ? relativePlacementPinsBefore : void 0,
-          relativePlacementPinsChanged ? relativePlacementPinsAfter : void 0
+          progressFallbackBefore,
+          progressFallbackAfter
         ),
         computeCoalesceKey(action),
         Date.now()
@@ -21783,11 +21523,7 @@ var ScheduleCore = class _ScheduleCore {
     return operation;
   }
   isCriticalPathSettled() {
-    return this._criticalPathRevision === this._scheduleRevision && // An admitted mutation has not landed yet, so whatever is applied now is
-    // about to be stale. Without this term `whenCriticalPathSettled` would
-    // spin: it would keep arming calculations that `isCurrent` kills on their
-    // first check, each one paying the project-wide deep copy first.
-    this._pendingScheduleRevision === this._scheduleRevision && this._activeCriticalPath === null;
+    return this._criticalPathRevision === this._scheduleRevision && this._pendingScheduleRevision === this._scheduleRevision && this._activeCriticalPath === null;
   }
   async whenCriticalPathSettled() {
     while (!this.isCriticalPathSettled()) {
@@ -21803,34 +21539,6 @@ var ScheduleCore = class _ScheduleCore {
     const merged = this._reapplyViewState(result.changes);
     return merged === null ? result : { ...result, changes: merged };
   }
-  _recordRelativePlacementPin(action, changes) {
-    const state = this.coreRuntime.state;
-    if (action.kind !== "activity-create") return;
-    const referenceId = action.afterSiblingId ?? action.beforeSiblingId ?? (action.eventSource === "Creation button (+)" && action.parentId !== ROOT_PARENT_ID ? action.parentId : void 0);
-    if (referenceId === void 0) return;
-    const created = changes.activities.find(({ kind }) => kind === "created");
-    if (created === void 0) return;
-    state.setRelativePlacementPin(created.id, {
-      referenceId,
-      branchParentId: action.parentId,
-      side: action.beforeSiblingId === void 0 ? "after" : "before"
-    });
-  }
-  /**
-   * The single place the two view-state passes are chained. Dispatch, undo and
-   * redo all route through here: when this existed only inside the dispatch
-   * 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 sequenced = this._emitTouchedBranchOrder(withFilter ?? changes);
@@ -21840,24 +21548,6 @@ var ScheduleCore = class _ScheduleCore {
     );
     return withOrder ?? sequenced.changes ?? 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;
     const touchedParents = collectResequencedParents(
@@ -21874,15 +21564,6 @@ var ScheduleCore = class _ScheduleCore {
     if (order.length === 0) return { changes: null, touchedParents };
     return { changes: { ...changes, order }, touchedParents };
   }
-  /**
-   * 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, resequencedParents) {
     const adapter = this.coreRuntime.state;
     if (adapter.getActiveOrder() === null) return null;
@@ -21917,22 +21598,15 @@ var ScheduleCore = class _ScheduleCore {
       context
     );
     const changedActivities = changesRequireFilterProjectionRebuild(changes) ? null : collectChangedActivities(changes, adapter);
-    const relativePlacementPins = adapter.getRelativePlacementPins();
     let affectedIds;
     let visibleIds;
-    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent || changesAffectRelativePinProjection(
-      changes,
-      changedActivities,
-      adapter,
-      relativePlacementPins
-    );
+    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent;
     if (needsProjectionRebuild) {
       const rebuiltProjection = buildFilterProjection({
         activities: adapter.getAllActivities(),
         parentOf: (activityId) => adapter.getParentId(activityId),
         filter,
-        context,
-        relativePlacementPins
+        context
       });
       adapter.setFilterProjection(rebuiltProjection);
       visibleIds = rebuiltProjection.visibleIds;
@@ -21988,11 +21662,7 @@ var ScheduleCore = class _ScheduleCore {
         this.coreRuntime.baseCalendars
       )
     );
-    const isCurrent = () => !cancellation.cancelled && this._status !== SCHEDULE_CORE_STATUS.DESTROYED && this._scheduleRevision === revision && // A mutation admitted but not yet settled is enough to make this result
-    // garbage. Without this term the calculation only learns it is obsolete
-    // when the mutation finishes, which measured live is the same instant the
-    // job itself ends.
-    this._pendingScheduleRevision === this._scheduleRevision;
+    const isCurrent = () => !cancellation.cancelled && this._status !== SCHEDULE_CORE_STATUS.DESTROYED && this._scheduleRevision === revision && this._pendingScheduleRevision === this._scheduleRevision;
     const promise = (async () => {
       const calculatedFields = await computeCriticalPathFields(
         isolatedState,
@@ -22345,7 +22015,7 @@ var CREATION_KIND = {
 exports.ACTIVITY_TYPE = ACTIVITY_TYPE;
 exports.CALENDAR_UNIT = CALENDAR_UNIT;
 exports.COLUMN = COLUMN;
-exports.CONSTRAINT_TYPE = CONSTRAINT_TYPE2;
+exports.CONSTRAINT_TYPE = CONSTRAINT_TYPE;
 exports.CONSTRAINT_TYPE_TO_LABEL = CONSTRAINT_TYPE_TO_LABEL;
 exports.CREATION_KIND = CREATION_KIND;
 exports.DEFAULT_HOURS_PER_DAY = DEFAULT_HOURS_PER_DAY;