@outbuild-company/schedule-core 1.3.0 → 1.4.0

package/dist/index.js

@@ -243,6 +243,23 @@ function dispatchVisibilitySet(action, deps) {
 }
 
 // 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;
@@ -351,20 +368,34 @@ var FIELD_REGISTRY = {
     extract: (activity) => activity.responsableIds
   },
   tagIds: { valueKind: "id-array", extract: (activity) => activity.tagIds },
-  status: { valueKind: "enum", extract: (activity) => activity.status },
+  status: {
+    valueKind: "enum",
+    order: STATUS_ORDER,
+    extract: (activity) => activity.status
+  },
   constraintType: {
     valueKind: "enum",
+    order: CONSTRAINT_TYPE_ORDER,
     extract: (activity) => activity.constraintType
   },
   calendarId: {
-    valueKind: "enum",
+    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: "enum",
-    extract: (activity) => activity.subcontractId
+    valueKind: "reference",
+    extract: (activity) => activity.subcontractId === null ? null : String(activity.subcontractId)
   },
-  isCritical: { valueKind: "enum", extract: (activity) => activity.isCritical }
+  // 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;
@@ -491,6 +522,12 @@ function evaluateVisibleIds(input) {
   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"]),
@@ -504,7 +541,11 @@ var OPERATORS_BY_KIND = {
   ]),
   date: /* @__PURE__ */ new Set(["after", "before"]),
   "id-array": /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
-  enum: /* @__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);
@@ -549,7 +590,7 @@ function resolveVisibleIds(adapter, filter, hoursPerDay) {
     activities,
     parentOf: (activityId) => adapter.getParentId(activityId),
     filter,
-    context: { hoursPerDay }
+    context: buildFilterContext(hoursPerDay)
   });
 }
 function dispatchFilterSet(action, deps) {
@@ -577,6 +618,140 @@ function dispatchFilterSet(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";
 
@@ -1883,15 +2058,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);
@@ -8941,6 +9107,7 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   "selection-replace",
   "visibility-set",
   "filter-set",
+  "sort-set",
   "sir-sync",
   "activity-lookahead-sync",
   "persistence-acknowledge",
@@ -8952,9 +9119,10 @@ var PURE_VIEW_STATE_KINDS = /* @__PURE__ */ new Set([
   "selection-toggle",
   "selection-replace",
   "visibility-set",
-  "filter-set"
+  "filter-set",
+  "sort-set"
 ]);
-function reappliesActiveFilter(action) {
+function reappliesViewState(action) {
   return !PURE_VIEW_STATE_KINDS.has(action.kind);
 }
 var NO_STRUCTURAL_EXEMPTIONS = /* @__PURE__ */ new Set();
@@ -9826,85 +9994,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?.();
@@ -12750,6 +12839,9 @@ async function dispatch(action, options, deps) {
       hoursPerDay: deps.sector.hoursPerDay
     });
   }
+  if (action.kind === "sort-set") {
+    return dispatchSortSet(action, { adapter: deps.adapter });
+  }
   if (action.kind === "sir-sync") {
     return dispatchSirSync(action, deps);
   }
@@ -15837,6 +15929,7 @@ var ViewStateStore = class {
   checkedSet = /* @__PURE__ */ new Set();
   hiddenSet = /* @__PURE__ */ new Set();
   activeFilter = null;
+  activeOrder = null;
   isChecked(activityId) {
     return this.checkedSet.has(activityId);
   }
@@ -15852,6 +15945,12 @@ var ViewStateStore = class {
   setActiveFilter(nextFilter) {
     this.activeFilter = nextFilter;
   }
+  getActiveOrder() {
+    return this.activeOrder;
+  }
+  setActiveOrder(nextOrder) {
+    this.activeOrder = nextOrder;
+  }
   checkedIds() {
     return [...this.checkedSet];
   }
@@ -15878,18 +15977,21 @@ var ViewStateStore = class {
     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
+      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;
   }
 };
 
@@ -15902,9 +16004,11 @@ var ScheduleState = class {
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
   _hierarchy;
+  _buildOrderComparator;
   _cache = {
     ids: null,
-    visualOrderIds: null
+    visualOrderIds: null,
+    orderComparator: null
   };
   _writeCapture = new WriteCapture();
   _viewState = new ViewStateStore();
@@ -15913,7 +16017,8 @@ var ScheduleState = class {
   _promotionSnapshotBefore = null;
   _calendar;
   _flags;
-  constructor(snapshot) {
+  constructor(snapshot, buildOrderComparator = () => null) {
+    this._buildOrderComparator = buildOrderComparator;
     for (const activity of snapshot.activities) {
       this._activities.set(activity.id, activity);
     }
@@ -16022,8 +16127,47 @@ var ScheduleState = class {
     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;
@@ -16223,6 +16367,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;
@@ -16348,7 +16493,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);
@@ -16492,7 +16637,7 @@ function mergeCoalesced(top, next) {
 }
 function getDispatchHistoryPolicy(action) {
   if (action.kind === "persistence-acknowledge") return "clear-on-success";
-  if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set") {
+  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";
@@ -16779,6 +16924,45 @@ 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 {
@@ -18092,6 +18276,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 = [];
@@ -18272,7 +18515,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);
@@ -18424,6 +18668,14 @@ var ScheduleCore = class {
     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()];
@@ -18540,7 +18792,7 @@ var ScheduleCore = class {
       this._saveTracker.snapshotLinks(this.getAllLinksView());
       this._undo.clear();
     }
-    result = this._withReappliedFilter(action, result);
+    result = this._withReappliedViewState(action, result);
     if (!result.ok) return result;
     if (dispatchChangesSchedulingState(action) && changeSetIsSubstantive(result.changes)) {
       this._recordScheduleMutation(options.skipCriticalPath !== true);
@@ -18562,11 +18814,82 @@ var ScheduleCore = class {
       await this.recomputeCriticalPath();
     }
   }
-  _withReappliedFilter(action, result) {
-    if (!result.ok || !reappliesActiveFilter(action)) return result;
-    const merged = this._reapplyActiveFilter(result.changes);
+  _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;
@@ -18575,7 +18898,7 @@ var ScheduleCore = class {
       activities: adapter.getAllActivities(),
       parentOf: (activityId) => adapter.getParentId(activityId),
       filter,
-      context: { hoursPerDay: this.coreRuntime.sector.hoursPerDay }
+      context: buildFilterContext(this.coreRuntime.sector.hoursPerDay)
     });
     const viewState = applyVisibleSet(adapter, visibleIds);
     if (viewState.length === 0) return null;
@@ -18734,7 +19057,7 @@ var ScheduleCore = class {
         entry,
         "before"
       );
-      return this._reapplyActiveFilter(changes) ?? changes;
+      return this._reapplyViewState(changes) ?? changes;
     });
     void operation.then(
       (changes) => {
@@ -18767,7 +19090,7 @@ var ScheduleCore = class {
         entry,
         "after"
       );
-      return this._reapplyActiveFilter(changes) ?? changes;
+      return this._reapplyViewState(changes) ?? changes;
     });
     void operation.then(
       (changes) => {
@@ -18901,6 +19224,7 @@ var DISPATCH_ACTION_KIND = {
   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"
 };
@@ -18927,6 +19251,7 @@ var KIND_CATALOG_COVERS_UNION = {
   [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
 };