@outbuild-company/schedule-core 1.28.0 → 1.29.0

package/dist/index.cjs

@@ -513,6 +513,8 @@ function createActivitiesApi(engine) {
     childIds: (parentId) => engine.getChildrenIds(parentId),
     hasChildren: (parentId) => engine.hasChild(parentId),
     indentTargetParentIds: (ids) => engine.getIndentTargetParentIds(ids),
+    leafParentIdsPromotedBy: (actions) => engine.getLeafParentIdsPromotedBy(actions),
+    lookaheadConfirmationFor: (actions, options) => engine.getLookaheadConfirmation(actions, options),
     isCustomIdInUse: (customId, currentCustomId) => engine.isCustomIdInUse(customId, currentCustomId ?? null),
     clipboard: () => engine.getActivityClipboardView(),
     create: (input, options) => engine.dispatch(
@@ -583,11 +585,14 @@ function createActivitiesApi(engine) {
       newValue: progress
     }),
     copy: (context = {}) => engine.dispatch({ ...context, kind: DISPATCH_ACTION_KIND.ACTIVITY_COPY }),
-    paste: (afterSiblingId, context = {}) => engine.dispatch({
-      ...context,
-      kind: DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED,
-      destination: { afterSiblingId }
-    }),
+    paste: (afterSiblingId, context = {}, options) => {
+      const action = {
+        ...context,
+        kind: DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED,
+        destination: { afterSiblingId }
+      };
+      return options === void 0 ? engine.dispatch(action) : engine.dispatch(action, options);
+    },
     duplicate: (activityIds, context = {}) => engine.dispatch({
       ...context,
       kind: DISPATCH_ACTION_KIND.ACTIVITY_DUPLICATE,
@@ -14845,6 +14850,184 @@ function resolveStartDate(parent, fallback, override) {
   return fallback ? new Date(fallback) : /* @__PURE__ */ new Date();
 }
 
+// src/activity-copy-paste/paste.ts
+function resolvePasteDestination(afterSiblingId, adapter) {
+  const sibling = adapter.getActivity(afterSiblingId);
+  if (!sibling) {
+    return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
+  }
+  if (sibling.parentId == null) {
+    return adapter.getRootIds().length === 1 ? {
+      ok: true,
+      parentId: sibling.id,
+      beforeSiblingId: adapter.getChildren(sibling.id)[0]
+    } : { ok: true, parentId: ROOT_PARENT_ID, afterSiblingId };
+  }
+  if (adapter.hasChildren(sibling.id)) {
+    return {
+      ok: true,
+      parentId: sibling.id,
+      beforeSiblingId: adapter.getChildren(sibling.id)[0]
+    };
+  }
+  return {
+    ok: true,
+    parentId: String(sibling.parentId),
+    afterSiblingId
+  };
+}
+var invariantFailure = () => ({
+  ok: false,
+  reason: REJECTION_REASON.ACTIVITY_PASTE_INVARIANT_FAILED
+});
+async function dispatchActivityPasteCopied(action, options, deps) {
+  const clipboard = deps.activityClipboard.value;
+  if (clipboard === null) {
+    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
+  }
+  const destination = resolvePasteDestination(
+    action.destination.afterSiblingId,
+    deps.adapter
+  );
+  if (!destination.ok) return destination;
+  const beforeSnapshot = await snapshotActivities(
+    deps.adapter,
+    /* @__PURE__ */ new Set()
+  );
+  const touched = /* @__PURE__ */ new Set();
+  const originalToNew = /* @__PURE__ */ new Map();
+  const createdIds = [];
+  let previousRootId;
+  for (const copied of clipboard.activities) {
+    const mappedParent = originalToNew.get(copied.originalParentId);
+    const afterSiblingId = mappedParent === void 0 ? previousRootId ?? destination.afterSiblingId : void 0;
+    const beforeSiblingId = mappedParent === void 0 && afterSiblingId === void 0 ? destination.beforeSiblingId : void 0;
+    const created = await createActivityCore(
+      {
+        kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
+        parentId: mappedParent ?? destination.parentId,
+        ...afterSiblingId === void 0 ? {} : { afterSiblingId },
+        ...beforeSiblingId === void 0 ? {} : { beforeSiblingId },
+        overrides: cloneDomainValue(copied.overrides),
+        eventSource: action.eventSource
+      },
+      deps,
+      {
+        skipCorrelativeRecompute: true,
+        skipBeforeSnap: true,
+        customIdReferenceId: action.destination.afterSiblingId,
+        confirmedLookaheadParentIds: options.confirmedLookaheadParentIds,
+        lookaheadTasksByActivityId: options.lookaheadTasksByActivityId
+      }
+    );
+    if (!created.ok) return created;
+    originalToNew.set(copied.originalId, created.newId);
+    createdIds.push(created.newId);
+    if (mappedParent === void 0) previousRootId = created.newId;
+  }
+  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(createdIds.map(String));
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot,
+    touched
+  );
+  for (const createdId of createdIds) touched.add(String(createdId));
+  const appliedLinks = [];
+  for (const copiedLink of clipboard.links) {
+    const source = originalToNew.get(copiedLink.source);
+    const target = originalToNew.get(copiedLink.target);
+    if (source === void 0 || target === void 0) return invariantFailure();
+    const operation = {
+      kind: LINK_OPERATION_KIND.CREATE,
+      source,
+      target,
+      type: copiedLink.type,
+      lag: copiedLink.lag
+    };
+    const result = applyLinkOperation(operation, {
+      port: deps.adapter,
+      newLinkId: deps.linkIdGen.next
+    });
+    if (!result.applied) return invariantFailure();
+    appliedLinks.push({
+      op: operation,
+      finalLinkId: result.linkId,
+      rejected: null
+    });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId,
+      runAutomaticP6Schedule: deps.runAutomaticP6Schedule
+    },
+    {
+      action,
+      autoscheduleFrom: createdIds[0] ?? null,
+      recomputeParentsFrom: createdIds,
+      now: deps.now,
+      options
+    }
+  );
+  const linkChanges = buildLinkChangesForBatch(
+    appliedLinks,
+    /* @__PURE__ */ new Map(),
+    deps.adapter
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap: beforeSnapshot,
+      touchedIds: touched,
+      scheduledIds,
+      links: linkChanges,
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+
+// src/dispatch/confirmations.ts
+var LOOKAHEAD_CONFIRMATION_KIND = {
+  HAS_LOOKAHEAD_TASKS: "has_lookahead_tasks"
+};
+
+// src/dispatch/shared/hierarchy-cycle-guard.ts
+function reparentClosesEffectiveCycle(adapter, reparented) {
+  const links = adapter.getAllLinks();
+  const verdict = validateTopologyCommit({
+    port: adapter,
+    currentLinks: links,
+    proposedLinks: links,
+    proposal: { reparented }
+  });
+  return !verdict.ok;
+}
+function collectCyclicReparents(planned, adapter) {
+  const cyclic = /* @__PURE__ */ new Set();
+  if (planned.length === 0) return cyclic;
+  const combined = new Map(
+    planned.map((reparent) => [reparent.activityId, reparent.newParentId])
+  );
+  if (!reparentClosesEffectiveCycle(adapter, combined)) return cyclic;
+  const accepted2 = /* @__PURE__ */ new Map();
+  for (const reparent of planned) {
+    const trial = new Map(accepted2);
+    trial.set(reparent.activityId, reparent.newParentId);
+    if (reparentClosesEffectiveCycle(adapter, trial)) {
+      cyclic.add(reparent.activityId);
+      continue;
+    }
+    accepted2.set(reparent.activityId, reparent.newParentId);
+  }
+  return cyclic;
+}
+
 // src/dispatch/shared/positional.ts
 function computeInsertionCorrelativeId(adapter, parentId, afterSiblingId, beforeSiblingId) {
   const parentKey = parentId;
@@ -14929,6 +15112,161 @@ function computeFractionalCidAtIndex(adapter, parentKey, targetIndex, excludeId)
   return (before + after) / 2;
 }
 
+// src/dispatch/shared/indent-planning.ts
+function planIndentMoves(activityIds, adapter) {
+  const selectedSet = new Set(activityIds);
+  const failed = [];
+  const moves = [];
+  const plannedIds = /* @__PURE__ */ new Set();
+  const blockingSet = new Set(selectedSet);
+  const sortedIds = [...activityIds].sort((a, b) => {
+    const aSnap = adapter.getActivity(a);
+    const bSnap = adapter.getActivity(b);
+    const ac = aSnap ? readCorrelativeId(aSnap) : NOT_SET_SORT_VALUE2;
+    const bc = bSnap ? readCorrelativeId(bSnap) : NOT_SET_SORT_VALUE2;
+    return ac - bc;
+  });
+  for (const id of sortedIds) {
+    const activity = adapter.getActivity(id);
+    if (!activity) {
+      failed.push({
+        activityId: id,
+        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
+      });
+      blockingSet.delete(id);
+      continue;
+    }
+    if (hasAncestorInSet(id, plannedIds, adapter)) continue;
+    const targetParentId = findPreviousNonSelectedSibling(
+      id,
+      blockingSet,
+      adapter
+    );
+    if (targetParentId == null) {
+      failed.push({
+        activityId: id,
+        reason: REJECTION_REASON.INDENT_NO_ELIGIBLE_SIBLING
+      });
+      blockingSet.delete(id);
+      continue;
+    }
+    const oldParentRaw = adapter.getActivity(id)?.parentId;
+    const oldParentId = isRootParent(oldParentRaw) ? ROOT_PARENT_ID : String(oldParentRaw);
+    moves.push({ activityId: id, newParentId: targetParentId, oldParentId });
+    plannedIds.add(id);
+  }
+  const cyclicMoveIds = collectCyclicReparents(moves, adapter);
+  for (const cyclicId of cyclicMoveIds) {
+    failed.push({
+      activityId: cyclicId,
+      reason: REJECTION_REASON.HIERARCHY_CYCLE
+    });
+  }
+  const allowedMoves = moves.filter(
+    (move) => !cyclicMoveIds.has(move.activityId)
+  );
+  return { moves, cyclicMoveIds, allowedMoves, failed };
+}
+
+// src/dispatch/shared/lookahead-parent-confirmation.ts
+function lookaheadParentsConfirmation(leafParents, options) {
+  const confirmed = new Set(options.confirmedLookaheadParentIds);
+  const facts = options.lookaheadTasksByActivityId;
+  const blocking = [
+    ...new Set(
+      leafParents.filter(
+        (parent) => !confirmed.has(String(parent.id)) && (facts?.[String(parent.id)] ?? parent.hasLookaheadTasks)
+      ).map((parent) => String(parent.id))
+    )
+  ];
+  const [first] = blocking;
+  if (first === void 0) return null;
+  return {
+    ok: false,
+    reason: REJECTION_REASON.CONFIRMATION_REQUIRED,
+    confirmation: {
+      kind: LOOKAHEAD_CONFIRMATION_KIND.HAS_LOOKAHEAD_TASKS,
+      activityId: first,
+      ...blocking.length > 1 ? { activityIds: blocking } : {}
+    }
+  };
+}
+function leafParentsPromotedBy(parentIds, adapter) {
+  const promoted = /* @__PURE__ */ new Map();
+  for (const parentId of parentIds) {
+    const parent = adapter.getActivity(parentId);
+    if (!parent) continue;
+    if (adapter.getChildren(parentId).length === 0)
+      promoted.set(String(parent.id), parent);
+  }
+  return [...promoted.values()];
+}
+function leafParentIdsPromotedByActions(actions, adapter, hasActivityClipboard) {
+  return leafParentsPromotedByActions(
+    actions,
+    adapter,
+    hasActivityClipboard
+  ).map((parent) => String(parent.id));
+}
+function lookaheadConfirmationForActions(actions, options, adapter, hasActivityClipboard) {
+  const rejection = lookaheadParentsConfirmation(
+    leafParentsPromotedByActions(actions, adapter, hasActivityClipboard),
+    options
+  );
+  return rejection === null ? null : rejection.confirmation;
+}
+function leafParentsPromotedByActions(actions, adapter, hasActivityClipboard) {
+  const parentIds = [];
+  for (const action of actions) {
+    parentIds.push(
+      ...targetParentIds(action, adapter, hasActivityClipboard).map(String)
+    );
+  }
+  return leafParentsPromotedBy(parentIds, adapter);
+}
+function targetParentIds(action, adapter, hasActivityClipboard) {
+  switch (action.kind) {
+    case DISPATCH_ACTION_KIND.ACTIVITY_CREATE:
+      return [action.parentId];
+    case DISPATCH_ACTION_KIND.ACTIVITY_MOVE: {
+      const activity = adapter.getActivity(action.activityId);
+      if (!activity) return [];
+      if (normalizeParentKey(activity.parentId) === String(action.parentId)) {
+        return [];
+      }
+      return movesIntoOwnBranch(action, adapter) ? [] : [action.parentId];
+    }
+    case DISPATCH_ACTION_KIND.ACTIVITY_INDENT:
+      return planIndentMoves(action.activityIds, adapter).allowedMoves.map(
+        (move) => move.newParentId
+      );
+    case DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED: {
+      if (!hasActivityClipboard) return [];
+      const destination = resolvePasteDestination(
+        action.destination.afterSiblingId,
+        adapter
+      );
+      return destination.ok ? [destination.parentId] : [];
+    }
+    case ACTIVITY_BATCH_ACTION_KIND:
+      return action.mode === ACTIVITY_BATCH_MODE.APPEND ? action.items.flatMap(
+        (item) => typeof item.parent === "string" ? [item.parent] : []
+      ) : [];
+    default:
+      return [];
+  }
+}
+function movesIntoOwnBranch(action, adapter) {
+  if (isRootParent(action.parentId)) return false;
+  if (action.parentId === action.activityId || adapter.isChildOf(action.parentId, action.activityId)) {
+    return true;
+  }
+  return reparentClosesEffectiveCycle(
+    adapter,
+    /* @__PURE__ */ new Map([[action.activityId, action.parentId]])
+  );
+}
+
 // src/dispatch/creation-overrides.ts
 var PUBLIC_CREATION_OVERRIDE_FIELDS = /* @__PURE__ */ new Set([
   ...[...CREATION_OVERRIDE_FIELDS].filter(
@@ -15395,7 +15733,7 @@ function removeIncidentLinks(activityId, deps) {
 async function createActivityCore(action, deps, opts = {}) {
   const { adapter, scheduler, sector, calendars, activityIdGen, uidGen } = deps;
   if (!opts.skipCacheInvalidation) scheduler.invalidateAllCaches();
-  const target = validateCreateTarget(action, adapter);
+  const target = validateCreateTarget(action, adapter, opts);
   if (!target.ok) return target;
   const { parent, anchorSiblingId, isRoot } = target;
   const newId = resolveNewActivityId(
@@ -15479,7 +15817,7 @@ async function createActivityCore(action, deps, opts = {}) {
     removedParentLinks
   };
 }
-function validateCreateTarget(action, adapter) {
+function validateCreateTarget(action, adapter, opts) {
   const isRoot = isRootParent(action.parentId);
   const parent = isRoot ? null : adapter.getActivity(action.parentId);
   if (!isRoot && !parent) {
@@ -15501,6 +15839,13 @@ function validateCreateTarget(action, adapter) {
     anchorSiblingId
   );
   if (anchorError) return anchorError;
+  if (parent !== null && !opts.parentsAlreadyChecked) {
+    const rejection = lookaheadParentsConfirmation(
+      leafParentsPromotedBy([action.parentId], adapter),
+      opts
+    );
+    if (rejection) return rejection;
+  }
   return { ok: true, parent, anchorSiblingId, isRoot };
 }
 function validateAnchorSibling(action, adapter, isRoot, anchorSiblingId) {
@@ -15599,7 +15944,11 @@ async function dispatchActivityCreate(action, options, deps) {
   if (!normalized2.ok) return normalized2;
   const core = await createActivityCore(
     { ...action, overrides: normalized2.value },
-    deps
+    deps,
+    {
+      confirmedLookaheadParentIds: options.confirmedLookaheadParentIds,
+      lookaheadTasksByActivityId: options.lookaheadTasksByActivityId
+    }
   );
   if (!core.ok) return core;
   const { newId } = core;
@@ -15656,6 +16005,13 @@ async function dispatchActivityBatch(action, options, deps) {
   if (validationError) return { ok: false, reason: validationError };
   const plan = buildBatchPlan(action, deps);
   if (!plan.ok) return plan;
+  if (action.mode === ACTIVITY_BATCH_MODE.APPEND) {
+    const rejection = lookaheadParentsConfirmation(
+      leafParentsPromotedBy(existingParentIds(plan.plan.items), deps.adapter),
+      options
+    );
+    if (rejection) return rejection;
+  }
   const existingActivityIds = action.mode === ACTIVITY_BATCH_MODE.REPLACE ? new Set(deps.adapter.getAllIds().map((id) => String(id))) : /* @__PURE__ */ new Set();
   const beforeSnap = action.mode === ACTIVITY_BATCH_MODE.REPLACE ? await snapshotActivities(deps.adapter, existingActivityIds) : /* @__PURE__ */ new Map();
   const beforeLinks = action.mode === ACTIVITY_BATCH_MODE.REPLACE ? snapshotAllLinks(deps) : /* @__PURE__ */ new Map();
@@ -15780,6 +16136,11 @@ async function dispatchActivityBatch(action, options, deps) {
     } : {}
   };
 }
+function existingParentIds(items) {
+  return items.filter(
+    (item) => item.parentBatchId === null && item.parentId !== ROOT_PARENT_ID
+  ).map((item) => String(item.parentId));
+}
 function validateBatch(action, deps) {
   if (action.mode !== ACTIVITY_BATCH_MODE.APPEND && action.mode !== ACTIVITY_BATCH_MODE.REPLACE) {
     return REJECTION_REASON.INVALID;
@@ -16077,7 +16438,8 @@ async function createPlannedActivities(action, plannedItems, deps) {
         skipBeforeSnap: true,
         skipCacheInvalidation: true,
         skipRollupCascades: true,
-        insertionCorrelativeId: item.insertionCorrelativeId
+        insertionCorrelativeId: item.insertionCorrelativeId,
+        parentsAlreadyChecked: true
       }
     );
     if (!core.ok) return core;
@@ -16840,37 +17202,6 @@ function isAncestor(descendantId, candidateAncestorId, adapter) {
   return false;
 }
 
-// src/dispatch/shared/hierarchy-cycle-guard.ts
-function reparentClosesEffectiveCycle(adapter, reparented) {
-  const links = adapter.getAllLinks();
-  const verdict = validateTopologyCommit({
-    port: adapter,
-    currentLinks: links,
-    proposedLinks: links,
-    proposal: { reparented }
-  });
-  return !verdict.ok;
-}
-function collectCyclicReparents(planned, adapter) {
-  const cyclic = /* @__PURE__ */ new Set();
-  if (planned.length === 0) return cyclic;
-  const combined = new Map(
-    planned.map((reparent) => [reparent.activityId, reparent.newParentId])
-  );
-  if (!reparentClosesEffectiveCycle(adapter, combined)) return cyclic;
-  const accepted2 = /* @__PURE__ */ new Map();
-  for (const reparent of planned) {
-    const trial = new Map(accepted2);
-    trial.set(reparent.activityId, reparent.newParentId);
-    if (reparentClosesEffectiveCycle(adapter, trial)) {
-      cyclic.add(reparent.activityId);
-      continue;
-    }
-    accepted2.set(reparent.activityId, reparent.newParentId);
-  }
-  return cyclic;
-}
-
 // src/dispatch/handlers/activity-move.ts
 async function dispatchActivityMove(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
@@ -16923,6 +17254,13 @@ async function dispatchActivityMove(action, options, deps) {
       return { ok: false, reason: REJECTION_REASON.HIERARCHY_CYCLE };
     }
   }
+  if (parentChanged && !newParentIsRoot) {
+    const rejection = lookaheadParentsConfirmation(
+      leafParentsPromotedBy([action.parentId], adapter),
+      options
+    );
+    if (rejection) return rejection;
+  }
   const touched = /* @__PURE__ */ new Set([action.activityId]);
   if (parentChanged) {
     if (oldParentKey !== ROOT_PARENT_ID) touched.add(oldParentKey);
@@ -17082,62 +17420,6 @@ async function dispatchActivityMove(action, options, deps) {
   };
 }
 
-// src/dispatch/shared/indent-planning.ts
-function planIndentMoves(activityIds, adapter) {
-  const selectedSet = new Set(activityIds);
-  const failed = [];
-  const moves = [];
-  const plannedIds = /* @__PURE__ */ new Set();
-  const blockingSet = new Set(selectedSet);
-  const sortedIds = [...activityIds].sort((a, b) => {
-    const aSnap = adapter.getActivity(a);
-    const bSnap = adapter.getActivity(b);
-    const ac = aSnap ? readCorrelativeId(aSnap) : NOT_SET_SORT_VALUE2;
-    const bc = bSnap ? readCorrelativeId(bSnap) : NOT_SET_SORT_VALUE2;
-    return ac - bc;
-  });
-  for (const id of sortedIds) {
-    const activity = adapter.getActivity(id);
-    if (!activity) {
-      failed.push({
-        activityId: id,
-        reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
-      });
-      blockingSet.delete(id);
-      continue;
-    }
-    if (hasAncestorInSet(id, plannedIds, adapter)) continue;
-    const targetParentId = findPreviousNonSelectedSibling(
-      id,
-      blockingSet,
-      adapter
-    );
-    if (targetParentId == null) {
-      failed.push({
-        activityId: id,
-        reason: REJECTION_REASON.INDENT_NO_ELIGIBLE_SIBLING
-      });
-      blockingSet.delete(id);
-      continue;
-    }
-    const oldParentRaw = adapter.getActivity(id)?.parentId;
-    const oldParentId = isRootParent(oldParentRaw) ? ROOT_PARENT_ID : String(oldParentRaw);
-    moves.push({ activityId: id, newParentId: targetParentId, oldParentId });
-    plannedIds.add(id);
-  }
-  const cyclicMoveIds = collectCyclicReparents(moves, adapter);
-  for (const cyclicId of cyclicMoveIds) {
-    failed.push({
-      activityId: cyclicId,
-      reason: REJECTION_REASON.HIERARCHY_CYCLE
-    });
-  }
-  const allowedMoves = moves.filter(
-    (move) => !cyclicMoveIds.has(move.activityId)
-  );
-  return { moves, cyclicMoveIds, allowedMoves, failed };
-}
-
 // src/dispatch/handlers/activity-indent.ts
 async function dispatchActivityIndent(action, options, deps) {
   const { adapter, scheduler, sector } = deps;
@@ -17159,6 +17441,14 @@ async function dispatchActivityIndent(action, options, deps) {
     }
   }
   const allowedMoves = plan.allowedMoves;
+  const rejection = lookaheadParentsConfirmation(
+    leafParentsPromotedBy(
+      allowedMoves.map((move) => move.newParentId),
+      adapter
+    ),
+    options
+  );
+  if (rejection) return rejection;
   const beforeSnap = await snapshotActivities(adapter, touched);
   for (const { activityId, newParentId } of allowedMoves) {
     adapter.setActivityField(activityId, ACTIVITY_PROPERTY.PARENT, newParentId);
@@ -18956,146 +19246,6 @@ function dispatchActivityClipboardImport(action, deps) {
   return clipboardOnlyResult(action);
 }
 
-// src/activity-copy-paste/paste.ts
-function resolveDestination(afterSiblingId, adapter) {
-  const sibling = adapter.getActivity(afterSiblingId);
-  if (!sibling) {
-    return { ok: false, reason: REJECTION_REASON.ANCHOR_SIBLING_NOT_FOUND };
-  }
-  if (sibling.parentId == null) {
-    return adapter.getRootIds().length === 1 ? {
-      ok: true,
-      parentId: sibling.id,
-      beforeSiblingId: adapter.getChildren(sibling.id)[0]
-    } : { ok: true, parentId: ROOT_PARENT_ID, afterSiblingId };
-  }
-  if (adapter.hasChildren(sibling.id)) {
-    return {
-      ok: true,
-      parentId: sibling.id,
-      beforeSiblingId: adapter.getChildren(sibling.id)[0]
-    };
-  }
-  return {
-    ok: true,
-    parentId: String(sibling.parentId),
-    afterSiblingId
-  };
-}
-var invariantFailure = () => ({
-  ok: false,
-  reason: REJECTION_REASON.ACTIVITY_PASTE_INVARIANT_FAILED
-});
-async function dispatchActivityPasteCopied(action, options, deps) {
-  const clipboard = deps.activityClipboard.value;
-  if (clipboard === null) {
-    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
-  }
-  const destination = resolveDestination(
-    action.destination.afterSiblingId,
-    deps.adapter
-  );
-  if (!destination.ok) return destination;
-  const beforeSnapshot = await snapshotActivities(
-    deps.adapter,
-    /* @__PURE__ */ new Set()
-  );
-  const touched = /* @__PURE__ */ new Set();
-  const originalToNew = /* @__PURE__ */ new Map();
-  const createdIds = [];
-  let previousRootId;
-  for (const copied of clipboard.activities) {
-    const mappedParent = originalToNew.get(copied.originalParentId);
-    const afterSiblingId = mappedParent === void 0 ? previousRootId ?? destination.afterSiblingId : void 0;
-    const beforeSiblingId = mappedParent === void 0 && afterSiblingId === void 0 ? destination.beforeSiblingId : void 0;
-    const created = await createActivityCore(
-      {
-        kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
-        parentId: mappedParent ?? destination.parentId,
-        ...afterSiblingId === void 0 ? {} : { afterSiblingId },
-        ...beforeSiblingId === void 0 ? {} : { beforeSiblingId },
-        overrides: cloneDomainValue(copied.overrides),
-        eventSource: action.eventSource
-      },
-      deps,
-      {
-        skipCorrelativeRecompute: true,
-        skipBeforeSnap: true,
-        customIdReferenceId: action.destination.afterSiblingId
-      }
-    );
-    if (!created.ok) return created;
-    originalToNew.set(copied.originalId, created.newId);
-    createdIds.push(created.newId);
-    if (mappedParent === void 0) previousRootId = created.newId;
-  }
-  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
-  const createdIdSet = new Set(createdIds.map(String));
-  foldCorrelativeShifts(
-    deps.adapter,
-    correlativeShifts,
-    createdIdSet,
-    beforeSnapshot,
-    touched
-  );
-  for (const createdId of createdIds) touched.add(String(createdId));
-  const appliedLinks = [];
-  for (const copiedLink of clipboard.links) {
-    const source = originalToNew.get(copiedLink.source);
-    const target = originalToNew.get(copiedLink.target);
-    if (source === void 0 || target === void 0) return invariantFailure();
-    const operation = {
-      kind: LINK_OPERATION_KIND.CREATE,
-      source,
-      target,
-      type: copiedLink.type,
-      lag: copiedLink.lag
-    };
-    const result = applyLinkOperation(operation, {
-      port: deps.adapter,
-      newLinkId: deps.linkIdGen.next
-    });
-    if (!result.applied) return invariantFailure();
-    appliedLinks.push({
-      op: operation,
-      finalLinkId: result.linkId,
-      rejected: null
-    });
-  }
-  const { scheduledIds } = await runPostMutation(
-    {
-      adapter: deps.adapter,
-      scheduler: deps.scheduler,
-      sector: deps.sector,
-      defaultBaseCalendarId: deps.defaultBaseCalendarId,
-      runAutomaticP6Schedule: deps.runAutomaticP6Schedule
-    },
-    {
-      action,
-      autoscheduleFrom: createdIds[0] ?? null,
-      recomputeParentsFrom: createdIds,
-      now: deps.now,
-      options
-    }
-  );
-  const linkChanges = buildLinkChangesForBatch(
-    appliedLinks,
-    /* @__PURE__ */ new Map(),
-    deps.adapter
-  );
-  return {
-    ok: true,
-    changes: await assembleChangeSet(deps.adapter, {
-      source: action,
-      beforeSnap: beforeSnapshot,
-      touchedIds: touched,
-      scheduledIds,
-      links: linkChanges,
-      hoursPerDay: deps.sector.hoursPerDay
-    })
-  };
-}
-
 // src/activity-copy-paste/duplicate.ts
 var CLONE_YIELD_EVERY_N = 200;
 var CREATE_OPTIONS = {
@@ -32112,6 +32262,41 @@ var ScheduleCore = class _ScheduleCore {
       ...new Set(plan.allowedMoves.map((move) => String(move.newParentId)))
     ];
   }
+  /**
+   * Lists the leaf activities the actions would turn into parents.
+   *
+   * Each action is checked against the current state, not against the state
+   * left by the actions before it.
+   *
+   * @param actions - Actions the caller is about to dispatch.
+   */
+  getLeafParentIdsPromotedBy(actions) {
+    this.assertReady();
+    return leafParentIdsPromotedByActions(
+      actions,
+      this.coreRuntime.state,
+      this._activityClipboard.value !== null
+    );
+  }
+  /**
+   * Returns the lookahead confirmation the dispatch rule would raise for the
+   * actions, or `null` when none is needed. The rule code is the dispatch rule
+   * and nothing changes in the schedule. Like
+   * {@link ScheduleCore.getLeafParentIdsPromotedBy}, it checks each action
+   * against the current state.
+   *
+   * @param actions - Actions the caller is about to dispatch.
+   * @param options - The `confirmedLookaheadParentIds` and `lookaheadTasksByActivityId` the dispatch would receive.
+   */
+  getLookaheadConfirmation(actions, options = {}) {
+    this.assertReady();
+    return lookaheadConfirmationForActions(
+      actions,
+      options,
+      this.coreRuntime.state,
+      this._activityClipboard.value !== null
+    );
+  }
   /**
    * Reads defensive direct-child snapshots in correlative order.
    *
@@ -34856,7 +35041,6 @@ var DEFAULT_HOURS_PER_DAY = 8;
 // src/creation/creation-kinds.ts
 var CREATION_KIND = {
   CHILD: "child",
-  CHILD_CONFIRMED: "child-confirmed",
   LINE: "line",
   ROOT: "root"
 };
@@ -34903,6 +35087,7 @@ exports.LINK_REJECTION_REASON = LINK_REJECTION_REASON;
 exports.LINK_RELATIONSHIP = LINK_RELATIONSHIP;
 exports.LINK_TYPE = LINK_TYPE;
 exports.LINK_TYPE_CODE = LINK_TYPE_CODE;
+exports.LOOKAHEAD_CONFIRMATION_KIND = LOOKAHEAD_CONFIRMATION_KIND;
 exports.LookaheadActualTransitionError = LookaheadActualTransitionError;
 exports.MINIMUM_GROUP_DEPTH = MINIMUM_GROUP_DEPTH;
 exports.MINIMUM_GROUP_LEVEL = MINIMUM_GROUP_LEVEL;