@outbuild-company/schedule-core 1.8.0 → 1.9.0

package/dist/index.cjs

@@ -420,6 +420,107 @@ function getFieldDescriptor(field) {
   return FIELD_REGISTRY[field] ?? null;
 }
 
+// src/internal/state/view-state.ts
+function isRelativePlacementPinValid(activityId, pin, parentOf) {
+  const branchParentId = String(pin.branchParentId);
+  const currentParentId = String(parentOf(activityId) ?? "0");
+  if (currentParentId !== branchParentId) return false;
+  const referenceId = String(pin.referenceId);
+  return referenceId === branchParentId || String(parentOf(referenceId) ?? "0") === branchParentId;
+}
+var ViewStateStore = class {
+  checkedSet = /* @__PURE__ */ new Set();
+  hiddenSet = /* @__PURE__ */ new Set();
+  activeFilter = null;
+  activeOrder = null;
+  relativePlacementPins = /* @__PURE__ */ new Map();
+  isChecked(activityId) {
+    return this.checkedSet.has(activityId);
+  }
+  isVisible(activityId) {
+    return !this.hiddenSet.has(activityId);
+  }
+  hiddenIds() {
+    return [...this.hiddenSet];
+  }
+  getActiveFilter() {
+    return this.activeFilter;
+  }
+  setActiveFilter(nextFilter) {
+    this.activeFilter = nextFilter;
+  }
+  getActiveOrder() {
+    return this.activeOrder;
+  }
+  setActiveOrder(nextOrder) {
+    this.activeOrder = nextOrder;
+  }
+  setRelativePlacementPin(activityId, pin) {
+    this.relativePlacementPins.set(String(activityId), {
+      referenceId: String(pin.referenceId),
+      branchParentId: String(pin.branchParentId),
+      side: pin.side
+    });
+  }
+  getRelativePlacementPins() {
+    return this.relativePlacementPins;
+  }
+  restoreRelativePlacementPins(pins) {
+    this.relativePlacementPins = new Map(pins);
+  }
+  checkedIds() {
+    return [...this.checkedSet];
+  }
+  checkedCount() {
+    return this.checkedSet.size;
+  }
+  setChecked(activityId, nextChecked) {
+    if (nextChecked === this.checkedSet.has(activityId)) return false;
+    if (nextChecked) this.checkedSet.add(activityId);
+    else this.checkedSet.delete(activityId);
+    return true;
+  }
+  setVisible(activityId, nextVisible) {
+    if (nextVisible === !this.hiddenSet.has(activityId)) return false;
+    if (nextVisible) this.hiddenSet.delete(activityId);
+    else this.hiddenSet.add(activityId);
+    return true;
+  }
+  forget(activityId) {
+    this.checkedSet.delete(activityId);
+    this.hiddenSet.delete(activityId);
+    this.relativePlacementPins.delete(activityId);
+    for (const [pinnedId, pin] of this.relativePlacementPins) {
+      if (pin.referenceId === activityId) {
+        this.relativePlacementPins.delete(pinnedId);
+      }
+    }
+  }
+  hydrate(seed2) {
+    this.checkedSet = new Set(seed2.checkedIds ?? []);
+    this.hiddenSet = new Set(seed2.hiddenIds ?? []);
+    this.activeFilter = null;
+    this.activeOrder = null;
+    this.relativePlacementPins = /* @__PURE__ */ new Map();
+  }
+  snapshot() {
+    return {
+      checked: new Set(this.checkedSet),
+      hidden: new Set(this.hiddenSet),
+      activeFilter: this.activeFilter,
+      activeOrder: this.activeOrder,
+      relativePlacementPins: new Map(this.relativePlacementPins)
+    };
+  }
+  restore(snapshot) {
+    this.checkedSet = new Set(snapshot.checked);
+    this.hiddenSet = new Set(snapshot.hidden);
+    this.activeFilter = snapshot.activeFilter;
+    this.activeOrder = snapshot.activeOrder;
+    this.relativePlacementPins = new Map(snapshot.relativePlacementPins);
+  }
+};
+
 // src/internal/filter/evaluate-filter.ts
 function toTargetDate(value) {
   if (value instanceof Date) return value;
@@ -562,13 +663,8 @@ function seedFilterProjection(input) {
       );
     }
     const isMatch = matchesFilter(activity, filter, context);
-    const isPinned = input.pinnedVisibleIds?.has(activityId) === true;
-    visibleReferenceCounts.set(
-      activityId,
-      (isMatch ? 1 : 0) + (isPinned ? 1 : 0)
-    );
+    visibleReferenceCounts.set(activityId, isMatch ? 1 : 0);
     if (isMatch) matchedIds.add(activityId);
-    if (isPinned) pinnedVisibleIds.add(activityId);
   }
   return {
     matchedIds,
@@ -578,6 +674,29 @@ function seedFilterProjection(input) {
     remainingChildren
   };
 }
+function applyRelativePlacementPins(seed2, pins) {
+  if (pins === void 0) return;
+  for (const [activityId, pin] of pins) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    if (!seed2.parentIds.has(pinnedId) || !seed2.parentIds.has(referenceId) || !isRelativePlacementPinValid(
+      pinnedId,
+      pin,
+      (activityId2) => seed2.parentIds.get(activityId2) ?? null
+    ) || (seed2.visibleReferenceCounts.get(referenceId) ?? 0) === 0) {
+      continue;
+    }
+    seed2.pinnedVisibleIds.add(pinnedId);
+    let currentId = pinnedId;
+    while (currentId !== null) {
+      seed2.visibleReferenceCounts.set(
+        currentId,
+        (seed2.visibleReferenceCounts.get(currentId) ?? 0) + 1
+      );
+      currentId = seed2.parentIds.get(currentId) ?? null;
+    }
+  }
+}
 function propagateVisibleReferenceCounts(seed2) {
   const { visibleReferenceCounts, parentIds, remainingChildren } = seed2;
   const pendingIds = [];
@@ -609,6 +728,7 @@ function collectVisibleIds(visibleReferenceCounts) {
 function buildFilterProjection(input) {
   const seed2 = seedFilterProjection(input);
   propagateVisibleReferenceCounts(seed2);
+  applyRelativePlacementPins(seed2, input.relativePlacementPins);
   const visibleIds = collectVisibleIds(seed2.visibleReferenceCounts);
   return {
     filter: input.filter,
@@ -796,7 +916,8 @@ function resolveFilter(adapter, filter, hoursPerDay) {
     activities,
     parentOf: (activityId) => adapter.getParentId(activityId),
     filter,
-    context: buildFilterContext(hoursPerDay)
+    context: buildFilterContext(hoursPerDay),
+    relativePlacementPins: adapter.getRelativePlacementPins()
   });
   return { visibleIds: projection.visibleIds, projection };
 }
@@ -847,25 +968,118 @@ function normalizeParentKey(parent) {
 
 // src/internal/hierarchy/visual-order.ts
 var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-function getChildrenInVisualOrder(parentId, adapter) {
+var EMPTY_RELATIVE_PLACEMENT_PINS = /* @__PURE__ */ new Map();
+function buildRelativePlacementPinIndex(adapter) {
+  const index = /* @__PURE__ */ new Map();
+  for (const [activityId, pin] of adapter.getRelativePlacementPins?.() ?? []) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    if (adapter.getActivity(pinnedId) === null || adapter.getActivity(referenceId) === null || !isRelativePlacementPinValid(
+      pinnedId,
+      pin,
+      (activityId2) => adapter.getParentId(activityId2)
+    )) {
+      continue;
+    }
+    const targetParentId = String(pin.branchParentId);
+    const branchPins = index.get(targetParentId) ?? /* @__PURE__ */ new Map();
+    branchPins.set(pinnedId, pin);
+    index.set(targetParentId, branchPins);
+  }
+  return index;
+}
+function getChildrenInVisualOrder(parentId, adapter, pinIndex = buildRelativePlacementPinIndex(adapter)) {
   const children = collectChildrenSnapshots(parentId, adapter);
   const userOrder = adapter.getOrderComparator?.() ?? null;
   children.sort(
     userOrder === null ? compareActivitiesInVisualOrder : (a, b) => userOrder(a, b) || compareActivitiesInVisualOrder(a, b)
   );
-  return children.map((a) => String(a.id));
+  return applyRelativePlacementPins2(
+    children.map((activity) => String(activity.id)),
+    parentId,
+    pinIndex.get(String(parentId)) ?? EMPTY_RELATIVE_PLACEMENT_PINS
+  );
+}
+function applyRelativePlacementPins2(orderedIds, parentId, pins) {
+  const order = buildLinkedActivityOrder(orderedIds);
+  for (const [activityId, pin] of pins) {
+    const pinnedId = String(activityId);
+    const referenceId = String(pin.referenceId);
+    const isFirstChild = referenceId === String(parentId);
+    if (!order.previous.has(pinnedId) || !isFirstChild && (!order.previous.has(referenceId) || pinnedId === referenceId)) {
+      continue;
+    }
+    detachActivity(order, pinnedId);
+    if (isFirstChild) insertActivityFirst(order, pinnedId);
+    else insertActivityBeside(order, pinnedId, referenceId, pin.side);
+  }
+  return materializeActivityOrder(order);
+}
+function buildLinkedActivityOrder(orderedIds) {
+  const previous = /* @__PURE__ */ new Map();
+  const next = /* @__PURE__ */ new Map();
+  for (let index = 0; index < orderedIds.length; index++) {
+    const activityId = orderedIds[index];
+    if (activityId === void 0) continue;
+    previous.set(activityId, orderedIds[index - 1] ?? null);
+    next.set(activityId, orderedIds[index + 1] ?? null);
+  }
+  return { previous, next, head: orderedIds[0] ?? null };
+}
+function detachActivity(order, activityId) {
+  const before = order.previous.get(activityId) ?? null;
+  const after = order.next.get(activityId) ?? null;
+  if (before === null) order.head = after;
+  else order.next.set(before, after);
+  if (after !== null) order.previous.set(after, before);
+}
+function insertActivityFirst(order, activityId) {
+  order.previous.set(activityId, null);
+  order.next.set(activityId, order.head);
+  if (order.head !== null) order.previous.set(order.head, activityId);
+  order.head = activityId;
+}
+function insertActivityBeside(order, activityId, referenceId, side) {
+  if (side === "before") {
+    const before = order.previous.get(referenceId) ?? null;
+    order.previous.set(activityId, before);
+    order.next.set(activityId, referenceId);
+    order.previous.set(referenceId, activityId);
+    if (before === null) order.head = activityId;
+    else order.next.set(before, activityId);
+    return;
+  }
+  const after = order.next.get(referenceId) ?? null;
+  order.previous.set(activityId, referenceId);
+  order.next.set(activityId, after);
+  order.next.set(referenceId, activityId);
+  if (after !== null) order.previous.set(after, activityId);
+}
+function materializeActivityOrder(order) {
+  const result = [];
+  let activityId = order.head;
+  while (activityId !== null) {
+    result.push(activityId);
+    activityId = order.next.get(activityId) ?? null;
+  }
+  return result;
 }
 function iterateInVisualOrder(adapter) {
   const result = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (activity) => {
     result.push(activity);
-    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
+    const childIds = getChildrenInVisualOrder(
+      String(activity.id),
+      adapter,
+      pinIndex
+    );
     for (const childId of childIds) {
       const child = adapter.getActivity(childId);
       if (child) visit(child);
     }
   };
-  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter, pinIndex);
   for (const rootId of rootIds) {
     const root = adapter.getActivity(rootId);
     if (root) visit(root);
@@ -926,8 +1140,9 @@ function setHas(set, id) {
 // src/dispatch/shared/collect-branch-order.ts
 function collectBranchOrder(adapter) {
   const branches = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   const visit = (parentId) => {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
     if (childIds.length > 1) {
       branches.push({ parentId, childIds });
     }
@@ -940,8 +1155,9 @@ function collectBranchOrder(adapter) {
 }
 function collectBranchOrderForParents(adapter, parentIds) {
   const branches = [];
+  const pinIndex = buildRelativePlacementPinIndex(adapter);
   for (const parentId of parentIds) {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    const childIds = getChildrenInVisualOrder(parentId, adapter, pinIndex);
     if (childIds.length > 1) branches.push({ parentId, childIds });
   }
   return branches;
@@ -4086,8 +4302,8 @@ var costPipeline = {
     }
     return canEdit();
   },
-  parseInput(rawValue, activity) {
-    if (String(rawValue).trim() === "") return parsed(activity.cost);
+  parseInput(rawValue) {
+    if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
     if (Number.isNaN(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
@@ -4136,8 +4352,8 @@ var usedCostPipeline = {
     }
     return canEdit();
   },
-  parseInput(rawValue, activity) {
-    if (String(rawValue).trim() === "") return parsed(activity.usedCost);
+  parseInput(rawValue) {
+    if (String(rawValue).trim() === "") return parsed(0);
     const numericValue = parseFloat(String(rawValue));
     if (Number.isNaN(numericValue)) return parseError("not_a_number");
     return parsed(numericValue);
@@ -17662,77 +17878,6 @@ 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();
@@ -17911,6 +18056,18 @@ 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
@@ -18117,10 +18274,14 @@ var ScheduleState = class _ScheduleState {
     const activity = this.getActivity(activityId);
     if (activity) this._writeCapture.noteRemove(String(activityId), activity);
     const key = String(activityId);
-    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key)) {
+    const relativePlacementPins = this._viewState.getRelativePlacementPins();
+    const hasDependentPin = [...relativePlacementPins.values()].some(
+      ({ referenceId }) => referenceId === key
+    );
+    if (this._viewState.isChecked(key) || !this._viewState.isVisible(key) || relativePlacementPins.has(key) || hasDependentPin) {
       this._captureViewStateOnce();
-      this._viewState.forget(key);
     }
+    this._viewState.forget(key);
     this._activities.delete(activityId);
     if (this._lastStartDate.has(String(activityId))) {
       this._captureLastStartDateOnce();
@@ -18378,13 +18539,15 @@ function buildHistoryChangeSet(changes) {
     links: linksWithoutAfter
   });
 }
-function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
+function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, relativePlacementPinsBefore, relativePlacementPinsAfter) {
   return {
     changeSet,
     beforeSnap,
     beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
     afterSnap,
-    afterLinks: resetDerivedLinkSnapshots(afterLinks)
+    afterLinks: resetDerivedLinkSnapshots(afterLinks),
+    relativePlacementPinsBefore,
+    relativePlacementPinsAfter
   };
 }
 function resetDerivedLinkSnapshots(snapshots) {
@@ -18687,6 +18850,8 @@ function applyChangeSetSide(state, entry, side) {
       );
     }
   }
+  const pins = side === "before" ? entry.relativePlacementPinsBefore : entry.relativePlacementPinsAfter;
+  if (pins !== void 0) state.restoreRelativePlacementPins(pins);
 }
 
 // src/dispatch/undo/undo-recorder.ts
@@ -21031,12 +21196,41 @@ 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;
@@ -21484,6 +21678,8 @@ 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(),
@@ -21520,18 +21716,26 @@ 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
+      );
       this._undo.record(
         buildUndoEntry(
           buildHistoryChangeSet(result.changes),
           result.__beforeSnap,
           result.__beforeLinks,
           created.afterSnap,
-          created.afterLinks
+          created.afterLinks,
+          relativePlacementPinsChanged ? relativePlacementPinsBefore : void 0,
+          relativePlacementPinsChanged ? relativePlacementPinsAfter : void 0
         ),
         computeCoalesceKey(action),
         Date.now()
@@ -21599,6 +21803,19 @@ 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
@@ -21621,39 +21838,7 @@ var ScheduleCore = class _ScheduleCore {
       sequenced.changes ?? withFilter ?? changes,
       sequenced.touchedParents
     );
-    const reapplied = withOrder ?? sequenced.changes ?? withFilter;
-    const finalChanges = reapplied ?? changes;
-    const createdIds = finalChanges.activities.filter((change) => change.kind === "created").map((change) => String(change.id));
-    if (createdIds.length === 0) return reapplied;
-    const createdAndAncestors = new Set(createdIds);
-    const filterProjection = this.coreRuntime.state.getFilterProjection();
-    for (const createdId of createdIds) {
-      if (filterProjection !== null) {
-        filterProjection.pinnedVisibleIds.add(createdId);
-      }
-      let activityId = createdId;
-      while (activityId !== null && activityId !== ROOT_PARENT_ID) {
-        createdAndAncestors.add(activityId);
-        if (filterProjection !== null) {
-          filterProjection.visibleIds.add(activityId);
-          filterProjection.visibleReferenceCounts.set(
-            activityId,
-            (filterProjection.visibleReferenceCounts.get(activityId) ?? 0) + 1
-          );
-        }
-        activityId = this.coreRuntime.state.getParentId(activityId);
-      }
-    }
-    const createdVisibility = applyVisibleSet(
-      this.coreRuntime.state,
-      createdAndAncestors,
-      createdAndAncestors
-    );
-    if (createdVisibility.length === 0) return reapplied;
-    return {
-      ...finalChanges,
-      viewState: [...finalChanges.viewState ?? [], ...createdVisibility]
-    };
+    return withOrder ?? sequenced.changes ?? withFilter;
   }
   /**
    * Emits `order` for the branches this mutation resequenced, when no user order
@@ -21732,16 +21917,22 @@ 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;
+    const needsProjectionRebuild = changedActivities === null || !projectionIsCurrent || changesAffectRelativePinProjection(
+      changes,
+      changedActivities,
+      adapter,
+      relativePlacementPins
+    );
     if (needsProjectionRebuild) {
       const rebuiltProjection = buildFilterProjection({
         activities: adapter.getAllActivities(),
         parentOf: (activityId) => adapter.getParentId(activityId),
         filter,
         context,
-        ...projectionIsCurrent ? { pinnedVisibleIds: projection.pinnedVisibleIds } : {}
+        relativePlacementPins
       });
       adapter.setFilterProjection(rebuiltProjection);
       visibleIds = rebuiltProjection.visibleIds;