@outbuild-company/schedule-core 1.20.1 → 1.22.0

package/dist/index.cjs

@@ -345,6 +345,10 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_COPY: "activity-copy",
   CALENDAR_RECONCILE: "calendar-reconcile",
   ACTIVITY_PASTE_COPIED: "activity-paste-copied",
+  ACTIVITY_DUPLICATE: "activity-duplicate",
+  CELL_COPY: "cell-copy",
+  CELL_CLIPBOARD_CLEAR: "cell-clipboard-clear",
+  CELL_PASTE_COPIED: "cell-paste-copied",
   PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
   BASELINE_APPLY: "baseline-apply",
   PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
@@ -593,6 +597,11 @@ function createActivitiesApi(engine) {
       kind: DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED,
       destination: { afterSiblingId }
     }),
+    duplicate: (activityIds, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_DUPLICATE,
+      activityIds
+    }),
     clearClipboard: (context = {}) => engine.dispatch({
       ...context,
       kind: DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR
@@ -611,6 +620,26 @@ function createActivitiesApi(engine) {
     createDateGesturePreview: (gesture) => engine.createDateGesturePreview(gesture)
   };
 }
+function createCellsApi(engine) {
+  return {
+    copy: (activityId, column, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.CELL_COPY,
+      activityId,
+      column
+    }),
+    paste: (activityIds, column, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.CELL_PASTE_COPIED,
+      activityIds,
+      column
+    }),
+    clearClipboard: (context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.CELL_CLIPBOARD_CLEAR
+    })
+  };
+}
 function createLinksApi(engine) {
   return {
     get: (id) => engine.getLinkView(id),
@@ -658,6 +687,7 @@ function createScheduleNamespaces(engine) {
   );
   return {
     activities: createActivitiesApi(engine),
+    cells: createCellsApi(engine),
     links: createLinksApi(engine),
     calendars: {
       get: (id) => engine.getCalendar(id),
@@ -919,6 +949,7 @@ var REJECTION_REASON = {
   NO_ACTIVITY_SELECTION: "no_activity_selection",
   CLIPBOARD_EMPTY: "clipboard_empty",
   ACTIVITY_PASTE_INVARIANT_FAILED: "activity_paste_invariant_failed",
+  SOLE_SCHEDULE_ROOT: "sole_schedule_root",
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
@@ -3887,7 +3918,7 @@ function applyLinkOperation(op, deps) {
       return applyDelete(op, deps);
   }
 }
-function applyLinkCreates(links, deps) {
+function validateLinkCreateBatch(links, deps) {
   if (links.length === 0) return { applied: true };
   const existingLinks = deps.port.getAllLinks();
   const duplicateKeys = /* @__PURE__ */ new Map();
@@ -3971,6 +4002,12 @@ function applyLinkCreates(links, deps) {
   if (!effectiveVerdict.ok) {
     return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
   }
+  return { applied: true };
+}
+function applyLinkCreates(links, deps) {
+  if (links.length === 0) return { applied: true };
+  const validation = validateLinkCreateBatch(links, deps);
+  if (!validation.applied) return validation;
   for (const { operation, linkId } of links) {
     const preserved = deps.preserved?.get(linkId);
     deps.port.addLink({
@@ -11708,6 +11745,8 @@ var NON_SCHEDULING_INLINE_COLUMNS = /* @__PURE__ */ new Set([
 var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
   DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR,
   DISPATCH_ACTION_KIND.ACTIVITY_COPY,
+  DISPATCH_ACTION_KIND.CELL_CLIPBOARD_CLEAR,
+  DISPATCH_ACTION_KIND.CELL_COPY,
   DISPATCH_ACTION_KIND.SELECTION_TOGGLE,
   DISPATCH_ACTION_KIND.SELECTION_REPLACE,
   DISPATCH_ACTION_KIND.VISIBILITY_SET,
@@ -11726,6 +11765,8 @@ var NON_SCHEDULING_KINDS = /* @__PURE__ */ new Set([
 var PURE_VIEW_STATE_KINDS = /* @__PURE__ */ new Set([
   DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR,
   DISPATCH_ACTION_KIND.ACTIVITY_COPY,
+  DISPATCH_ACTION_KIND.CELL_CLIPBOARD_CLEAR,
+  DISPATCH_ACTION_KIND.CELL_COPY,
   DISPATCH_ACTION_KIND.SELECTION_TOGGLE,
   DISPATCH_ACTION_KIND.SELECTION_REPLACE,
   DISPATCH_ACTION_KIND.VISIBILITY_SET,
@@ -11743,7 +11784,7 @@ function reappliesViewState(action) {
 }
 var NO_STRUCTURAL_EXEMPTIONS = /* @__PURE__ */ new Set();
 function editsOnlyNonSchedulingColumns(action) {
-  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT) {
+  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT || action.kind === DISPATCH_ACTION_KIND.CELL_PASTE_COPIED) {
     return NON_SCHEDULING_INLINE_COLUMNS.has(action.column);
   }
   if (action.kind === DISPATCH_ACTION_KIND.BULK_EDIT) {
@@ -11754,7 +11795,7 @@ function editsOnlyNonSchedulingColumns(action) {
   return false;
 }
 function editsOnlyDataDateColumns(action) {
-  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT) {
+  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT || action.kind === DISPATCH_ACTION_KIND.CELL_PASTE_COPIED) {
     return DATA_DATE_COLUMNS.has(action.column);
   }
   return action.kind === DISPATCH_ACTION_KIND.BULK_EDIT && action.edits.every((edit) => DATA_DATE_COLUMNS.has(edit.column));
@@ -11796,6 +11837,9 @@ function dispatchChangesProgress(action) {
   if (action.kind === DISPATCH_ACTION_KIND.BULK_EDIT) {
     return action.edits.some((edit) => edit.column === COLUMN.PROGRESS);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.CELL_PASTE_COPIED) {
+    return action.column === COLUMN.PROGRESS;
+  }
   return false;
 }
 function resolveRunRealCost(action) {
@@ -11811,7 +11855,7 @@ var PROGRESS_AFFECTING_COLUMNS = /* @__PURE__ */ new Set([
 ]);
 function shouldRecomputeParentProgress(action) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS) return true;
-  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT) {
+  if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT || action.kind === DISPATCH_ACTION_KIND.CELL_PASTE_COPIED) {
     return PROGRESS_AFFECTING_COLUMNS.has(action.column);
   }
   if (action.kind === DISPATCH_ACTION_KIND.BULK_EDIT) {
@@ -12783,6 +12827,15 @@ function mergeScheduledIds(firstSettleIds, secondSettleIds) {
 }
 
 // src/dispatch/shared/helpers.ts
+function getIncidentLinkSnapshots(adapter, activityId, isPredecessors) {
+  const incidentLinkIds = isPredecessors ? adapter.getIncomingLinkIds(activityId) : adapter.getOutgoingLinkIds(activityId);
+  const links = [];
+  for (const linkId of incidentLinkIds) {
+    const link = adapter.getLink(linkId);
+    if (link) links.push(link);
+  }
+  return links;
+}
 function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
   const out = [];
   for (const { op, finalLinkId, rejected: rejected2 } of applied) {
@@ -14009,12 +14062,11 @@ async function dispatchInlineEditLinks(action, options, deps) {
     byCorrelative.set(String(a.correlativeId), a.id);
   });
   const resolve = (corr) => byCorrelative.get(corr) ?? null;
-  const incidentLinkIds = isPredecessors ? adapter.getIncomingLinkIds(action.activityId) : adapter.getOutgoingLinkIds(action.activityId);
-  const currentLinks = [];
-  for (const linkId of incidentLinkIds) {
-    const link = adapter.getLink(linkId);
-    if (link) currentLinks.push(link);
-  }
+  const currentLinks = getIncidentLinkSnapshots(
+    adapter,
+    action.activityId,
+    isPredecessors
+  );
   const diff = isPredecessors ? diffLinks({
     targetActivityId: action.activityId,
     currentLinks,
@@ -18482,6 +18534,457 @@ async function dispatchActivityPasteCopied(action, options, deps) {
   };
 }
 
+// src/activity-copy-paste/duplicate.ts
+var CLONE_YIELD_EVERY_N = 200;
+var CREATE_OPTIONS = {
+  skipCorrelativeRecompute: true,
+  skipBeforeSnap: true,
+  skipCacheInvalidation: true,
+  skipRollupCascades: true
+};
+async function dispatchActivityDuplicate(action, options, deps) {
+  const resolved = resolveDuplicateRuns(action.activityIds, deps.adapter);
+  if (!resolved.ok) return resolved;
+  const frozenParent = firstFrozenRunParent(resolved.runs, deps.adapter);
+  if (frozenParent) {
+    return { ok: false, reason: REJECTION_REASON.PARENT_FROZEN_BY_SIR };
+  }
+  deps.scheduler.invalidateAllCaches();
+  const beforeSnapshot = await snapshotActivities(
+    deps.adapter,
+    /* @__PURE__ */ new Set()
+  );
+  const state = {
+    originalToNew: /* @__PURE__ */ new Map(),
+    createdIds: [],
+    createdParentIds: []
+  };
+  for (const run of resolved.runs) {
+    const lastOriginal = run.originals.at(-1);
+    if (!lastOriginal) continue;
+    let anchorId = lastOriginal.id;
+    for (const original of run.originals) {
+      anchorId = await cloneSubtree(
+        original,
+        run.parentId,
+        anchorId,
+        action,
+        deps,
+        state
+      );
+    }
+  }
+  recomputeCreatedParentRollups(state, deps);
+  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(state.createdIds.map(String));
+  const touched = /* @__PURE__ */ new Set();
+  seedJournalBeforeImages(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot
+  );
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot,
+    touched
+  );
+  for (const createdId of state.createdIds) touched.add(String(createdId));
+  const applied = replicateInternalLinks(state, deps);
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: state.createdIds.length > 0 ? AUTOSCHEDULE_SCOPE.ROOTS : null,
+      recomputeParentsFrom: state.createdIds,
+      preventSummaryTargetPullback: true,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap: beforeSnapshot,
+      touchedIds: touched,
+      scheduledIds,
+      links: buildLinkChangesForBatch(
+        applied,
+        /* @__PURE__ */ new Map(),
+        deps.adapter
+      ),
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+function resolveDuplicateRuns(activityIds, adapter) {
+  if (activityIds.length === 0) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
+  }
+  const requested = /* @__PURE__ */ new Set();
+  const originals = [];
+  for (const rawId of activityIds) {
+    const activityId = String(rawId);
+    if (requested.has(activityId)) continue;
+    const activity = adapter.getActivity(activityId);
+    if (!activity) {
+      return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+    }
+    requested.add(activityId);
+    originals.push(activity);
+  }
+  const roots = originals.filter(
+    (activity) => !hasAncestorInSet(activity.id, requested, adapter)
+  );
+  const duplicatesSoleScheduleRoot = adapter.getRootIds().length === 1 && roots.some((activity) => activity.parentId == null);
+  if (duplicatesSoleScheduleRoot) {
+    return { ok: false, reason: REJECTION_REASON.SOLE_SCHEDULE_ROOT };
+  }
+  return { ok: true, runs: groupIntoContiguousRuns(roots, adapter) };
+}
+function firstFrozenRunParent(runs, adapter) {
+  const checked = /* @__PURE__ */ new Set();
+  for (const run of runs) {
+    if (run.parentId === ROOT_PARENT_ID || checked.has(String(run.parentId))) {
+      continue;
+    }
+    checked.add(String(run.parentId));
+    const parent = adapter.getActivity(run.parentId);
+    if (parent && isFrozen(parent)) return parent;
+  }
+  return null;
+}
+function groupIntoContiguousRuns(roots, adapter) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const activity of roots) {
+    const parentKey = normalizeParentKey(activity.parentId);
+    const group = byParent.get(parentKey) ?? [];
+    group.push(activity);
+    byParent.set(parentKey, group);
+  }
+  const runs = [];
+  for (const [parentKey, group] of byParent) {
+    const parentId = parentKey === ROOT_PARENT_ID ? ROOT_PARENT_ID : parentKey;
+    const positions = new Map(
+      childrenInCorrelativeOrder(adapter, parentKey).map(
+        (sibling, index) => [String(sibling.id), index]
+      )
+    );
+    const positionOf = (activity) => positions.get(String(activity.id)) ?? -1;
+    const ordered = [...group].sort(
+      (left, right) => positionOf(left) - positionOf(right)
+    );
+    for (const originals of splitContiguous(ordered, positionOf)) {
+      runs.push({ parentId, originals });
+    }
+  }
+  return runs;
+}
+function splitContiguous(ordered, positionOf) {
+  const runs = [];
+  let previousPosition = null;
+  for (const activity of ordered) {
+    const position = positionOf(activity);
+    const lastRun = runs.at(-1);
+    if (lastRun && previousPosition !== null && position === previousPosition + 1) {
+      lastRun.push(activity);
+    } else {
+      runs.push([activity]);
+    }
+    previousPosition = position;
+  }
+  return runs;
+}
+function seedJournalBeforeImages(adapter, shifts, excludeIds, beforeSnap) {
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return;
+  for (const shift of shifts) {
+    if (excludeIds.has(shift.activityId) || beforeSnap.has(shift.activityId)) {
+      continue;
+    }
+    const beforeImage = journal.before.get(shift.activityId);
+    if (beforeImage) beforeSnap.set(shift.activityId, beforeImage);
+  }
+}
+function childrenInCorrelativeOrder(adapter, parentKey) {
+  return collectSiblings(adapter, parentKey).sort((left, right) => {
+    const diff = readCorrelativeId(left) - readCorrelativeId(right);
+    return diff || String(left.id).localeCompare(String(right.id));
+  });
+}
+async function cloneSubtree(original, parentId, anchorId, action, deps, state) {
+  const root = await createActivityCore(
+    {
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
+      parentId,
+      afterSiblingId: anchorId,
+      overrides: copyOverrides(original),
+      ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+    },
+    deps,
+    { ...CREATE_OPTIONS, customIdReferenceId: original.id }
+  );
+  if (!root.ok) throw invariantViolation("create", root.reason);
+  registerCreated(state, original, root.newId, parentId);
+  await cloneDescendantsIteratively(original, root.newId, action, deps, state);
+  return root.newId;
+}
+async function cloneDescendantsIteratively(rootOriginal, rootNewParentId, action, deps, state) {
+  const pending = new Queue();
+  pending.enqueue({ original: rootOriginal, newParentId: rootNewParentId });
+  let processed = 0;
+  while (!pending.isEmpty()) {
+    const { original, newParentId } = pending.dequeue();
+    for (const child of childrenInCorrelativeOrder(
+      deps.adapter,
+      String(original.id)
+    )) {
+      const created = await createActivityCore(
+        {
+          kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
+          parentId: newParentId,
+          overrides: copyOverrides(child),
+          ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+        },
+        deps,
+        CREATE_OPTIONS
+      );
+      if (!created.ok) throw invariantViolation("create", created.reason);
+      registerCreated(state, child, created.newId, newParentId);
+      pending.enqueue({ original: child, newParentId: created.newId });
+      processed += 1;
+      if (processed % CLONE_YIELD_EVERY_N === 0) await yieldToBrowser();
+    }
+  }
+}
+function invariantViolation(step, reason) {
+  return new Error(
+    `[ScheduleCore] activity-duplicate: unexpected ${step} rejection after preflight passed (${reason})`
+  );
+}
+function registerCreated(state, original, newId, parentId) {
+  state.originalToNew.set(String(original.id), newId);
+  state.createdIds.push(newId);
+  state.createdParentIds.push(parentId);
+}
+function recomputeCreatedParentRollups(state, deps) {
+  const recomputed = /* @__PURE__ */ new Set();
+  for (const parentId of [...state.createdParentIds].reverse()) {
+    if (parentId === ROOT_PARENT_ID || recomputed.has(String(parentId))) {
+      continue;
+    }
+    recomputed.add(String(parentId));
+    recomputeRollupCascadesForParent(parentId, deps.adapter);
+  }
+}
+function replicateInternalLinks(state, deps) {
+  const applied = [];
+  for (const originalId of state.originalToNew.keys()) {
+    for (const linkId of deps.adapter.getOutgoingLinkIds(originalId)) {
+      const link = deps.adapter.getLink(linkId);
+      if (!link) continue;
+      const source = state.originalToNew.get(String(link.source));
+      const target = state.originalToNew.get(String(link.target));
+      if (source === void 0 || target === void 0) continue;
+      const operation = {
+        kind: LINK_OPERATION_KIND.CREATE,
+        source,
+        target,
+        type: link.type,
+        lag: link.lag
+      };
+      const result = applyLinkOperation(operation, {
+        port: deps.adapter,
+        newLinkId: deps.linkIdGen.next
+      });
+      if (!result.applied) {
+        throw invariantViolation(
+          "link",
+          result.rejected ?? REJECTION_REASON.INVALID
+        );
+      }
+      applied.push({
+        op: operation,
+        finalLinkId: result.linkId,
+        rejected: null
+      });
+    }
+  }
+  return applied;
+}
+
+// src/cell-copy-paste/copy.ts
+var CELL_CLIPBOARD_KIND = {
+  FIELD: "field",
+  LINKS: "links"
+};
+function copyLinkSpecs(adapter, activityId, isPredecessors) {
+  return getIncidentLinkSnapshots(adapter, activityId, isPredecessors).map(
+    (link) => ({
+      otherActivityId: isPredecessors ? link.source : link.target,
+      type: link.type,
+      lag: link.lag
+    })
+  );
+}
+function emptyChangeSet(action) {
+  return {
+    ok: true,
+    changes: {
+      source: action,
+      activities: [],
+      links: [],
+      calendars: [],
+      trackingEvents: []
+    }
+  };
+}
+function dispatchCellCopy(action, deps) {
+  const activity = deps.adapter.getActivity(action.activityId);
+  if (!activity) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  if (action.column === COLUMN.CUSTOM_PREDECESSORS || action.column === COLUMN.CUSTOM_SUCESSORS) {
+    deps.clipboard.value = {
+      kind: CELL_CLIPBOARD_KIND.LINKS,
+      specs: copyLinkSpecs(
+        deps.adapter,
+        action.activityId,
+        action.column === COLUMN.CUSTOM_PREDECESSORS
+      )
+    };
+    return emptyChangeSet(action);
+  }
+  const pipeline = findPipelineForColumn(action.column);
+  if (!pipeline) {
+    return { ok: false, reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN };
+  }
+  const canonicalValue = readPipelineTargetValue(activity, pipeline.targetField);
+  if (action.column === COLUMN.DURATION && !Number.isFinite(canonicalValue)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  const raw = action.column === COLUMN.DURATION ? canonicalValue / deps.hoursPerDay : cloneDomainValue(canonicalValue);
+  deps.clipboard.value = { kind: CELL_CLIPBOARD_KIND.FIELD, raw };
+  return emptyChangeSet(action);
+}
+function dispatchCellClipboardClear(action, clipboard) {
+  clipboard.value = null;
+  return emptyChangeSet(action);
+}
+
+// src/cell-copy-paste/paste.ts
+function toDiffPlaceholder(activityId) {
+  return String(activityId);
+}
+function fromDiffPlaceholder(adapter, placeholder) {
+  const activityId = placeholder;
+  return adapter.activityExists(activityId) ? activityId : null;
+}
+function linkOperationsForTarget(targetActivityId, isPredecessors, clipboard, deps) {
+  const desiredSpecs = clipboard.specs.map((spec) => ({
+    correlativeId: toDiffPlaceholder(spec.otherActivityId),
+    type: spec.type,
+    lag: spec.lag
+  }));
+  const currentLinks = getIncidentLinkSnapshots(
+    deps.adapter,
+    targetActivityId,
+    isPredecessors
+  );
+  const resolve = (placeholder) => fromDiffPlaceholder(deps.adapter, placeholder);
+  const diff = isPredecessors ? diffLinks({
+    targetActivityId,
+    currentLinks,
+    desiredSpecs,
+    resolveActivityByCorrelative: resolve
+  }) : diffOutgoingLinks({
+    sourceActivityId: targetActivityId,
+    currentLinks,
+    desiredSpecs,
+    resolveActivityByCorrelative: resolve
+  });
+  return diff.operations;
+}
+async function dispatchCellPasteCopied(action, options, deps) {
+  const clipboard = deps.cellClipboard.value;
+  if (clipboard === null) {
+    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
+  }
+  if (action.activityIds.length === 0) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
+  }
+  const hasMissingActivity = action.activityIds.some(
+    (activityId) => !deps.adapter.activityExists(activityId)
+  );
+  if (hasMissingActivity) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  if (action.column === COLUMN.CUSTOM_PREDECESSORS || action.column === COLUMN.CUSTOM_SUCESSORS) {
+    if (clipboard.kind !== CELL_CLIPBOARD_KIND.LINKS) {
+      return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+    }
+    const hasSelfReference = action.activityIds.some(
+      (activityId) => clipboard.specs.some(
+        (spec) => String(spec.otherActivityId) === String(activityId)
+      )
+    );
+    if (hasSelfReference) {
+      return { ok: false, reason: LINK_REJECTION_REASON.SELF_LINK };
+    }
+    const isPredecessors = action.column === COLUMN.CUSTOM_PREDECESSORS;
+    const operations = action.activityIds.flatMap(
+      (activityId) => linkOperationsForTarget(activityId, isPredecessors, clipboard, deps)
+    );
+    const createEntries = operations.filter(
+      (operation) => operation.kind === LINK_OPERATION_KIND.CREATE
+    ).map((operation) => ({
+      operation,
+      linkId: deps.linkIdGen.next()
+    }));
+    const creation = validateLinkCreateBatch(createEntries, {
+      port: deps.adapter,
+      rejectParentLinkMutations: options.rejectParentLinkMutations ?? false
+    });
+    if (!creation.applied) {
+      return {
+        ok: false,
+        reason: creation.rejected ?? REJECTION_REASON.INVALID
+      };
+    }
+    return dispatchLinkBatch(operations, action, options, deps);
+  }
+  if (clipboard.kind !== CELL_CLIPBOARD_KIND.FIELD) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  if (!findPipelineForColumn(action.column)) {
+    return { ok: false, reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN };
+  }
+  const column = action.column;
+  const result = await dispatchBulkEdit(
+    {
+      kind: DISPATCH_ACTION_KIND.BULK_EDIT,
+      edits: action.activityIds.map((activityId) => ({
+        activityId,
+        column,
+        newValue: clipboard.raw
+      })),
+      ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+    },
+    options,
+    deps
+  );
+  if (!result.ok) return result;
+  return { ...result, changes: { ...result.changes, source: action } };
+}
+
 // src/dispatch/dispatch.ts
 async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_COPY) {
@@ -18499,6 +19002,22 @@ async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED) {
     return dispatchActivityPasteCopied(action, options, deps);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_DUPLICATE) {
+    return dispatchActivityDuplicate(action, options, deps);
+  }
+  if (action.kind === DISPATCH_ACTION_KIND.CELL_COPY) {
+    return dispatchCellCopy(action, {
+      adapter: deps.adapter,
+      clipboard: deps.cellClipboard,
+      hoursPerDay: deps.sector.hoursPerDay
+    });
+  }
+  if (action.kind === DISPATCH_ACTION_KIND.CELL_CLIPBOARD_CLEAR) {
+    return dispatchCellClipboardClear(action, deps.cellClipboard);
+  }
+  if (action.kind === DISPATCH_ACTION_KIND.CELL_PASTE_COPIED) {
+    return dispatchCellPasteCopied(action, options, deps);
+  }
   if (action.kind === ACTIVITY_BATCH_ACTION_KIND) {
     return dispatchActivityBatch(action, options, deps);
   }
@@ -30171,7 +30690,7 @@ function validateP6EndingActivitySearch(input) {
     );
   }
 }
-function emptyChangeSet(source) {
+function emptyChangeSet2(source) {
   return {
     source,
     activities: [],
@@ -30209,6 +30728,8 @@ function isCurrentFilterProjection(projection, filter, context) {
 var ScheduleCore = class _ScheduleCore {
   /** Activity reads and mutations. */
   activities;
+  /** Single-cell clipboard reads and mutations. */
+  cells;
   /** Dependency-link reads and mutations. */
   links;
   /** Calendar reads and reconciliation. */
@@ -30246,6 +30767,7 @@ var ScheduleCore = class _ScheduleCore {
     schedule: (patch) => this._scheduleP6(patch)
   });
   _activityClipboard = { value: null };
+  _cellClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
   _isFork;
@@ -30290,6 +30812,9 @@ var ScheduleCore = class _ScheduleCore {
       this._activityClipboard.value = cloneDomainValue(
         source._activityClipboard.value
       );
+      this._cellClipboard.value = cloneDomainValue(
+        source._cellClipboard.value
+      );
       this._undo = source._undo.fork();
       this._saveTracker = source._saveTracker.fork();
       this._scheduleRevision = source._scheduleRevision;
@@ -31518,7 +32043,7 @@ var ScheduleCore = class _ScheduleCore {
             });
             continue;
           }
-          const changes = emptyChangeSet(action);
+          const changes = emptyChangeSet2(action);
           results.push({ ok: true, changes });
           acceptedChangeSets.push(changes);
           acceptedActions.push(action);
@@ -31647,6 +32172,7 @@ var ScheduleCore = class _ScheduleCore {
         customIdTracker: this.coreRuntime.customIdTracker,
         reporter: this.coreRuntime.reporter,
         activityClipboard: this._activityClipboard,
+        cellClipboard: this._cellClipboard,
         stateRevision: this._stateRevision,
         defaultBaseCalendarId: this.coreRuntime.baseCalendars.find(
           (calendar) => calendar.baseDefault