@outbuild-company/schedule-core 1.14.2 → 1.15.0

package/dist/index.js

@@ -341,6 +341,7 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_MOVE: "activity-move",
   ACTIVITY_INDENT: "activity-indent",
   ACTIVITY_OUTDENT: "activity-outdent",
+  ACTIVITY_TYPE_SET: "activity-type-set",
   ACTIVITY_SET_PROGRESS: "activity-set-progress",
   ACTIVITY_LOOKAHEAD_CONVERT: "activity-lookahead-convert",
   SELECTION_TOGGLE: "selection-toggle",
@@ -349,7 +350,8 @@ var DISPATCH_ACTION_KIND = {
   FILTER_SET: "filter-set",
   SORT_SET: "sort-set",
   SIR_SYNC: "sir-sync",
-  ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
+  ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync",
+  SCHEDULE_AUTO_SCHEDULE: "schedule-auto-schedule"
 };
 var ACTIVITY_BATCH_ACTION_KIND = "activity-batch";
 var DISPATCH_LINK_OPERATION_KIND = LINK_OPERATION_KIND;
@@ -449,6 +451,8 @@ function batchLink(operation) {
     return {
       kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
       linkId: operation.linkId,
+      ...operation.sourceId === void 0 ? {} : { source: operation.sourceId },
+      ...operation.targetId === void 0 ? {} : { target: operation.targetId },
       ...operation.relationship === void 0 ? {} : { type: linkType(operation.relationship) },
       ...operation.lagDays === void 0 ? {} : { lag: operation.lagDays }
     };
@@ -505,6 +509,14 @@ function createActivitiesApi(engine) {
       },
       options
     ),
+    setType: (activityId, type, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.ACTIVITY_TYPE_SET,
+        activityId,
+        type
+      },
+      options
+    ),
     applyDragBatch: (edits, options) => engine.dispatch(
       {
         kind: DISPATCH_ACTION_KIND.DATES_BATCH,
@@ -566,6 +578,13 @@ function createActivitiesApi(engine) {
       ...input,
       kind: DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC
     }),
+    autoSchedule: (activityId, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.SCHEDULE_AUTO_SCHEDULE,
+        ...activityId === void 0 ? {} : { activityId }
+      },
+      options
+    ),
     createDateGesturePreview: (gesture) => engine.createDateGesturePreview(gesture)
   };
 }
@@ -589,6 +608,8 @@ function createLinksApi(engine) {
       {
         kind: DISPATCH_ACTION_KIND.LINK_UPDATE,
         linkId,
+        ...patch.sourceId === void 0 ? {} : { source: patch.sourceId },
+        ...patch.targetId === void 0 ? {} : { target: patch.targetId },
         ...patch.relationship === void 0 ? {} : { type: linkType(patch.relationship) },
         ...patch.lagDays === void 0 ? {} : { lag: patch.lagDays }
       },
@@ -1902,6 +1923,87 @@ function assertNever(value, message) {
   throw new Error(message);
 }
 
+// src/activity-types/behavior.ts
+var PONDERATOR_WEIGHT = {
+  OWN_BASELINE: "own-baseline",
+  RECURSIVE_LEAF_SUM: "recursive-leaf-sum",
+  ZERO: "zero"
+};
+var ACTIVITY_TYPE_BEHAVIOR = {
+  [ACTIVITY_TYPE.PROJECT]: {
+    alwaysSummary: true,
+    holdsConstraint: false,
+    carriesCustomId: false,
+    forcedDuration: null,
+    ponderatorWeight: PONDERATOR_WEIGHT.RECURSIVE_LEAF_SUM,
+    promotesToProjectOnFirstChild: false
+  },
+  [ACTIVITY_TYPE.TASK]: {
+    alwaysSummary: false,
+    holdsConstraint: true,
+    carriesCustomId: true,
+    forcedDuration: null,
+    ponderatorWeight: PONDERATOR_WEIGHT.OWN_BASELINE,
+    promotesToProjectOnFirstChild: true
+  },
+  [ACTIVITY_TYPE.MILESTONE]: {
+    alwaysSummary: false,
+    holdsConstraint: true,
+    carriesCustomId: true,
+    forcedDuration: 0,
+    ponderatorWeight: PONDERATOR_WEIGHT.ZERO,
+    promotesToProjectOnFirstChild: true
+  }
+};
+
+// src/activity-types/predicates.ts
+function isSummary(type, hasChildren) {
+  return hasChildren || isActivityType(type) && ACTIVITY_TYPE_BEHAVIOR[type].alwaysSummary;
+}
+function isMilestoneType(type) {
+  return type === ACTIVITY_TYPE.MILESTONE;
+}
+function isPromotableLeafType(type) {
+  return isActivityType(type) && ACTIVITY_TYPE_BEHAVIOR[type].promotesToProjectOnFirstChild;
+}
+
+// src/activity-types/transitions.ts
+var PROMOTION_TARGET_TYPE = ACTIVITY_TYPE.PROJECT;
+var DEMOTION_TARGET_TYPE = ACTIVITY_TYPE.TASK;
+function typeForNewDuration(currentDuration, newDuration) {
+  if (newDuration === 0) return ACTIVITY_TYPE.MILESTONE;
+  if (currentDuration === 0 && newDuration > 0) return ACTIVITY_TYPE.TASK;
+  return null;
+}
+
+// src/constants/activity-properties.ts
+var ACTIVITY_PROPERTY = {
+  PARENT: "parentId",
+  TYPE: "type",
+  START_DATE: "startDate",
+  END_DATE: "endDate",
+  DURATION_HOURS: "durationHours",
+  CONSTRAINT_TYPE: "constraintType",
+  CONSTRAINT_DATE: "constraintDate",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "usedCost",
+  REAL_COST: "realCost",
+  WORK_HOURS: "workHours",
+  REAL_WORK_HOURS: "realWorkHours",
+  CORRELATIVE_ID: "correlativeId",
+  CUSTOM_ID: "customId",
+  NEW_ACTIVITIES_ARRAY: "newActivityIds",
+  HAS_NEW_ACTIVITIES: "hasNewActivities",
+  CALENDAR_DURATION: "calendarDuration"};
+var LINK_PROPERTY = {
+  SOURCE: "source",
+  TARGET: "target",
+  TYPE: "type",
+  LAG: "lag",
+  FREE_SLACK_HOURS: "freeSlackHours",
+  IS_CRITICAL: "isCritical"};
+
 // src/autoscheduler/utils/cancellation.ts
 function createIsCurrent(id, getCurrentId) {
   return () => getCurrentId() === id;
@@ -2012,59 +2114,6 @@ function filterTopoOrder(order, scopedIds) {
   return filtered;
 }
 
-// src/activity-types/behavior.ts
-var PONDERATOR_WEIGHT = {
-  OWN_BASELINE: "own-baseline",
-  RECURSIVE_LEAF_SUM: "recursive-leaf-sum",
-  ZERO: "zero"
-};
-var ACTIVITY_TYPE_BEHAVIOR = {
-  [ACTIVITY_TYPE.PROJECT]: {
-    alwaysSummary: true,
-    holdsConstraint: false,
-    carriesCustomId: false,
-    forcedDuration: null,
-    ponderatorWeight: PONDERATOR_WEIGHT.RECURSIVE_LEAF_SUM,
-    promotesToProjectOnFirstChild: false
-  },
-  [ACTIVITY_TYPE.TASK]: {
-    alwaysSummary: false,
-    holdsConstraint: true,
-    carriesCustomId: true,
-    forcedDuration: null,
-    ponderatorWeight: PONDERATOR_WEIGHT.OWN_BASELINE,
-    promotesToProjectOnFirstChild: true
-  },
-  [ACTIVITY_TYPE.MILESTONE]: {
-    alwaysSummary: false,
-    holdsConstraint: true,
-    carriesCustomId: true,
-    forcedDuration: 0,
-    ponderatorWeight: PONDERATOR_WEIGHT.ZERO,
-    promotesToProjectOnFirstChild: true
-  }
-};
-
-// src/activity-types/predicates.ts
-function isSummary(type, hasChildren) {
-  return hasChildren || isActivityType(type) && ACTIVITY_TYPE_BEHAVIOR[type].alwaysSummary;
-}
-function isMilestoneType(type) {
-  return type === ACTIVITY_TYPE.MILESTONE;
-}
-function isPromotableLeafType(type) {
-  return isActivityType(type) && ACTIVITY_TYPE_BEHAVIOR[type].promotesToProjectOnFirstChild;
-}
-
-// src/activity-types/transitions.ts
-var PROMOTION_TARGET_TYPE = ACTIVITY_TYPE.PROJECT;
-var DEMOTION_TARGET_TYPE = ACTIVITY_TYPE.TASK;
-function typeForNewDuration(currentDuration, newDuration) {
-  if (newDuration === 0) return ACTIVITY_TYPE.MILESTONE;
-  if (currentDuration === 0 && newDuration > 0) return ACTIVITY_TYPE.TASK;
-  return null;
-}
-
 // src/autoscheduler/utils/parent-link-expansion.ts
 function isSummary2(id, adapter) {
   const activity = adapter.getActivity(id);
@@ -3538,6 +3587,53 @@ function applyLinkUpdate(op, port) {
   if (!link) {
     return { applied: false, rejected: LINK_REJECTION_REASON.LINK_MISSING };
   }
+  const proposed = {
+    ...link,
+    source: op.source ?? link.source,
+    target: op.target ?? link.target,
+    type: op.type ?? link.type,
+    lag: op.lag ?? link.lag
+  };
+  if (String(proposed.source) === String(proposed.target)) {
+    return { applied: false, rejected: LINK_REJECTION_REASON.SELF_LINK };
+  }
+  if (!port.getActivity(proposed.source) || !port.getActivity(proposed.target)) {
+    return {
+      applied: false,
+      rejected: LINK_REJECTION_REASON.ACTIVITY_MISSING
+    };
+  }
+  if (isSummaryHierarchyLink(proposed.source, proposed.target, port)) {
+    return {
+      applied: false,
+      rejected: LINK_REJECTION_REASON.HIERARCHY_LINK
+    };
+  }
+  const currentLinks = port.getAllLinks();
+  const duplicate = currentLinks.find(
+    (candidate) => String(candidate.id) !== String(op.linkId) && linkKey(candidate) === linkKey(proposed)
+  );
+  if (duplicate) {
+    return {
+      applied: false,
+      rejected: LINK_REJECTION_REASON.DUPLICATE,
+      linkId: duplicate.id
+    };
+  }
+  const proposedLinks = currentLinks.map(
+    (candidate) => String(candidate.id) === String(op.linkId) ? proposed : candidate
+  );
+  const effectiveVerdict = validateTopologyCommit({
+    port,
+    currentLinks,
+    proposedLinks
+  });
+  if (!effectiveVerdict.ok) {
+    return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
+  }
+  if (String(link.source) !== String(proposed.source) || String(link.target) !== String(proposed.target)) {
+    port.setLinkEndpoints(op.linkId, proposed.source, proposed.target);
+  }
   if (op.lag !== void 0) port.setLinkField(op.linkId, "lag", op.lag);
   if (op.type !== void 0) port.setLinkField(op.linkId, "type", op.type);
   return { applied: true, linkId: op.linkId };
@@ -4020,10 +4116,7 @@ function adjustLinkLagOnTaskMove(targetId, adapter, preEditTarget) {
       calendarApi
     );
     if (newLag === link.lag) continue;
-    applyLinkUpdate(
-      { kind: LINK_OPERATION_KIND.UPDATE, linkId: link.id, lag: newLag },
-      adapter
-    );
+    adapter.setLinkField(link.id, LINK_PROPERTY.LAG, newLag);
   }
 }
 
@@ -5587,6 +5680,7 @@ var CONSTRAINT_WARNING_KIND = {
   VIOLATION: "constraint_violation"
 };
 var CHANGE_SET_SOURCE_KIND = {
+  DISPATCH_MANY: "dispatch-many",
   INIT: "init",
   UNDO: "undo",
   REDO: "redo"
@@ -5636,32 +5730,6 @@ var COLUMN_WRITABLE_FIELDS = new Set(
   COLUMN_WRITABLE_FIELD_LIST
 );
 
-// src/constants/activity-properties.ts
-var ACTIVITY_PROPERTY = {
-  PARENT: "parentId",
-  TYPE: "type",
-  START_DATE: "startDate",
-  END_DATE: "endDate",
-  DURATION_HOURS: "durationHours",
-  CONSTRAINT_TYPE: "constraintType",
-  CONSTRAINT_DATE: "constraintDate",
-  PROGRESS: "progress",
-  COST: "cost",
-  USED_COST: "usedCost",
-  REAL_COST: "realCost",
-  WORK_HOURS: "workHours",
-  REAL_WORK_HOURS: "realWorkHours",
-  CORRELATIVE_ID: "correlativeId",
-  CUSTOM_ID: "customId",
-  NEW_ACTIVITIES_ARRAY: "newActivityIds",
-  HAS_NEW_ACTIVITIES: "hasNewActivities",
-  CALENDAR_DURATION: "calendarDuration"};
-var LINK_PROPERTY = {
-  TYPE: "type",
-  LAG: "lag",
-  FREE_SLACK_HOURS: "freeSlackHours",
-  IS_CRITICAL: "isCritical"};
-
 // src/internal/state/dynamic-writes.ts
 function setActivityFieldDynamic(state, activityId, field, value) {
   state.setActivityFieldDynamic(activityId, field, value);
@@ -10916,48 +10984,267 @@ function cloneLink(link) {
   return { ...link };
 }
 
-// src/dispatch/shared/post-mutation.ts
-var AUTOSCHEDULE_SCOPE = { ROOTS: "roots" };
-async function runPostMutation(deps, args) {
-  const progressInvalidation = resolveProgressInvalidation(deps.adapter);
-  const passes = resolvePasses(args, progressInvalidation);
-  if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
-    await refreshMutatedParentBounds(deps.adapter, args);
-  }
-  const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(
-    deps,
-    args.autoscheduleFrom,
-    args.preventSummaryTargetPullback
-  ) : emptySchedule();
-  await rollUpParentBounds(
-    deps.adapter,
-    args,
-    schedule.scheduledIds,
-    passes,
-    progressInvalidation
-  );
-  await runDerivedRecomputes(deps, passes, args.now);
-  return schedule;
-}
-function resolvePasses(args, progressInvalidation) {
-  const requested = args.autoscheduleFrom !== null;
-  const ran = !args.options.skipAutoSchedule && requested;
-  const passes = new Set(
-    resolveDerivedPasses(args.action, { ran }, args.options)
-  );
-  if (args.recomputeParentProgress || progressInvalidation.affectedParents.size > 0) {
-    passes.add(DERIVED_PASS.PARENT_PROGRESS);
+// src/dispatch/sir-auto-reject.ts
+function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
+  const effects = [];
+  for (const id of touchedIds) {
+    const before = beforeSnap.get(id);
+    if (!before) continue;
+    const pendingRequestIds = before.pendingRequestIds ?? [];
+    if (!isFrozen({ pendingRequestIds })) continue;
+    if (adapter.getActivity(id) != null) continue;
+    for (const pending of pendingRequestIds) {
+      effects.push({
+        kind: SCHEDULE_EFFECT_KIND.SIR_AUTO_REJECT,
+        activityId: id,
+        sirId: pending,
+        reason: SIR_AUTO_REJECT_REASON.ACTIVITY_DELETED
+      });
+    }
   }
-  return passes;
+  return effects;
 }
-function resolveProgressInvalidation(adapter) {
-  const affectedParents = /* @__PURE__ */ new Set();
-  const dirtySeeds = /* @__PURE__ */ new Set();
-  const journal = adapter.peekWriteCapture();
-  if (!journal) return { affectedParents, dirtySeeds };
-  const affectParent = (parentId) => {
-    if (parentId === null || isRootParent(parentId)) return;
-    const normalized2 = String(parentId);
+
+// src/dispatch/conversion.ts
+function snapshotToLink(l) {
+  const view = {
+    id: String(l.id),
+    source: String(l.source),
+    target: String(l.target),
+    type: l.type,
+    lag: Number(l.lag),
+    freeSlackHours: typeof l.freeSlackHours === "number" && Number.isFinite(l.freeSlackHours) ? l.freeSlackHours : null,
+    isCritical: l.isCritical === true
+  };
+  if (l.proplannerId != null) view.proplannerId = Number(l.proplannerId);
+  if (l.ganttId != null) view.ganttId = Number(l.ganttId);
+  if (l.sectorId != null) view.sectorId = Number(l.sectorId);
+  return view;
+}
+
+// src/dispatch/shared/change-set.ts
+var SIR_DETECTION_PHASE = {
+  BEFORE_DIFF: "before-diff",
+  AFTER_DIFF: "after-diff"
+};
+async function assembleChangeSet(adapter, args) {
+  const allTouched = collectChangeSetIds(adapter, args);
+  const before = new Map(args.beforeSnap);
+  const captured = adapter.peekWriteCapture();
+  if (captured) {
+    const insertedIds = collectInsertedIds(captured);
+    mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
+  }
+  const sirDetection = args.sirDetection;
+  const beforeDiffEffects = sirDetection === SIR_DETECTION_PHASE.BEFORE_DIFF ? detectSirAutoReject(before, adapter, allTouched) : [];
+  const correlativeBefore = buildCorrelativeBeforeMap(
+    args.correlativeShifts,
+    allTouched
+  );
+  const activityChanges = await buildActivityChanges(
+    adapter,
+    before,
+    allTouched,
+    correlativeBefore
+  );
+  const effects = sirDetection === SIR_DETECTION_PHASE.AFTER_DIFF ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
+  const warnings = args.warnings ?? [];
+  const linkChanges = mergeLinkChanges(
+    args.links ?? [],
+    captured ? buildCapturedCriticalPathLinkChanges(adapter, captured) : []
+  );
+  return {
+    source: args.source,
+    activities: activityChanges,
+    links: linkChanges,
+    calendars: [],
+    trackingEvents: args.trackingEvents ?? [],
+    ...effects.length > 0 ? { effects } : {},
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function buildCapturedCriticalPathLinkChanges(adapter, captured) {
+  const changes = [];
+  for (const operation of captured.ops) {
+    if (operation.kind !== WRITE_OPERATION_KIND.LINK_FIELD) continue;
+    const after = adapter.getLink(operation.linkId);
+    if (!after) continue;
+    const fields = {};
+    for (const field of ["freeSlackHours", "isCritical"]) {
+      if (!Object.is(operation.before[field], after[field])) {
+        fields[field] = {
+          before: operation.before[field],
+          after: after[field]
+        };
+      }
+    }
+    if (Object.keys(fields).length === 0) continue;
+    changes.push({
+      id: operation.linkId,
+      kind: ENTITY_CHANGE_KIND.UPDATED,
+      fields,
+      after: snapshotToLink(after)
+    });
+  }
+  return changes;
+}
+function mergeLinkChanges(explicit, captured) {
+  const merged = [];
+  const indexById = /* @__PURE__ */ new Map();
+  for (const change of explicit) {
+    const index = indexById.get(change.id);
+    if (index === void 0) {
+      indexById.set(change.id, merged.length);
+      merged.push(change);
+      continue;
+    }
+    const current = merged[index];
+    if ((current.kind === ENTITY_CHANGE_KIND.UPDATED || current.kind === ENTITY_CHANGE_KIND.CREATED) && change.kind === ENTITY_CHANGE_KIND.UPDATED) {
+      merged[index] = {
+        ...current,
+        fields: { ...current.fields, ...change.fields },
+        after: change.after
+      };
+      continue;
+    }
+    merged[index] = change;
+  }
+  for (const change of captured) {
+    const index = indexById.get(change.id);
+    if (index === void 0) {
+      indexById.set(change.id, merged.length);
+      merged.push(change);
+      continue;
+    }
+    const current = merged[index];
+    if (current.kind === ENTITY_CHANGE_KIND.DELETED) continue;
+    const capturedFields = current.kind === ENTITY_CHANGE_KIND.CREATED ? Object.fromEntries(
+      Object.entries(change.fields ?? {}).map(([field, value]) => [
+        field,
+        { before: void 0, after: value.after }
+      ])
+    ) : change.fields;
+    merged[index] = {
+      ...current,
+      fields: { ...current.fields, ...capturedFields },
+      after: change.after
+    };
+  }
+  return merged;
+}
+function buildCorrelativeBeforeMap(shifts, touched) {
+  if (!shifts || shifts.length === 0) return void 0;
+  const correlativeBefore = /* @__PURE__ */ new Map();
+  for (const shift of shifts) {
+    correlativeBefore.set(shift.activityId, shift.before);
+    touched.add(shift.activityId);
+  }
+  return correlativeBefore;
+}
+function collectChangeSetIds(adapter, args) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of args.touchedIds) ids.add(id);
+  for (const id of args.scheduledIds) ids.add(id);
+  if (args.includeAllIds) {
+    for (const id of adapter.getAllIds()) ids.add(id);
+  }
+  return ids;
+}
+function mergeDirtyBeforeImages(adapter, captured, insertedIds, before, touched) {
+  for (const id of captured.dirty) {
+    if (insertedIds.has(id) || before.has(id)) continue;
+    const beforeImage = captured.before.get(id);
+    const live = adapter.getActivity(id);
+    if (!beforeImage || !live) continue;
+    if (Object.keys(diffActivity(beforeImage, live)).length === 0) continue;
+    before.set(id, beforeImage);
+    touched.add(id);
+  }
+}
+function collectInsertedIds(captured) {
+  return new Set(
+    captured.ops.filter((operation) => operation.kind === WRITE_OPERATION_KIND.INSERT).map((operation) => operation.activityId)
+  );
+}
+
+// src/dispatch/shared/post-mutation.ts
+var AUTOSCHEDULE_SCOPE = { ROOTS: "roots" };
+async function runPostMutation(deps, args) {
+  const progressInvalidation = resolveProgressInvalidation(deps.adapter);
+  const passes = resolvePasses(args, progressInvalidation);
+  if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
+    await refreshMutatedParentBounds(deps.adapter, args);
+  }
+  const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(
+    deps,
+    args.autoscheduleFrom,
+    args.preventSummaryTargetPullback
+  ) : emptySchedule();
+  await rollUpParentBounds(
+    deps.adapter,
+    args,
+    schedule.scheduledIds,
+    passes,
+    progressInvalidation
+  );
+  await runDerivedRecomputes(deps, passes, args.now);
+  return schedule;
+}
+async function dispatchScheduleAutoSchedule(action, options, deps) {
+  if (action.activityId !== void 0 && !deps.adapter.activityExists(action.activityId)) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  const beforeSnap = await snapshotActivities(
+    deps.adapter,
+    new Set(deps.adapter.getAllIds())
+  );
+  deps.scheduler.invalidateAllCaches();
+  const recomputeParentsFrom = action.activityId === void 0 ? deps.adapter.getRootIds() : [action.activityId];
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: action.activityId ?? AUTOSCHEDULE_SCOPE.ROOTS,
+      recomputeParentsFrom,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: recomputeParentsFrom,
+      scheduledIds,
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+function resolvePasses(args, progressInvalidation) {
+  const requested = args.autoscheduleFrom !== null;
+  const ran = !args.options.skipAutoSchedule && requested;
+  const passes = new Set(
+    resolveDerivedPasses(args.action, { ran }, args.options)
+  );
+  if (args.recomputeParentProgress || progressInvalidation.affectedParents.size > 0) {
+    passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  }
+  return passes;
+}
+function resolveProgressInvalidation(adapter) {
+  const affectedParents = /* @__PURE__ */ new Set();
+  const dirtySeeds = /* @__PURE__ */ new Set();
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return { affectedParents, dirtySeeds };
+  const affectParent = (parentId) => {
+    if (parentId === null || isRootParent(parentId)) return;
+    const normalized2 = String(parentId);
     affectedParents.add(normalized2);
     const childId = adapter.getChildren(normalized2)[0];
     if (childId !== void 0) dirtySeeds.add(childId);
@@ -11006,8 +11293,27 @@ async function runAutoschedule(deps, autoscheduleFrom, preventSummaryTargetPullb
   }
   const result = await deps.scheduler.schedule(options);
   const outcome = captureScheduledRows(deps.adapter, result.updatedIds);
+  const warnings = collectConstraintWarnings(deps.adapter, result);
   applyResults(deps.adapter, result);
-  return outcome;
+  return { ...outcome, warnings };
+}
+function collectConstraintWarnings(adapter, result) {
+  const warnings = [];
+  for (const plan of result.plans.values()) {
+    const projectedDate = plan.earliestSchedulingStart;
+    if (!projectedDate || plan.startDate >= projectedDate) continue;
+    const activity = adapter.getActivity(plan.activityId);
+    if (!activity?.constraintType || !activity.constraintDate) continue;
+    warnings.push({
+      kind: CONSTRAINT_WARNING_KIND.VIOLATION,
+      activityId: activity.id,
+      constraintType: activity.constraintType,
+      constraintDate: activity.constraintDate,
+      projectedDate,
+      messageKey: CONSTRAINT_WARNING_KIND.VIOLATION
+    });
+  }
+  return warnings;
 }
 function captureScheduledRows(adapter, updatedIds) {
   const scheduledIds = [];
@@ -11019,10 +11325,10 @@ function captureScheduledRows(adapter, updatedIds) {
       adapter.noteScheduledBefore(activityId, snap);
     }
   }
-  return { scheduledIds };
+  return { scheduledIds, warnings: [] };
 }
 function emptySchedule() {
-  return { scheduledIds: [] };
+  return { scheduledIds: [], warnings: [] };
 }
 async function refreshMutatedParentBounds(adapter, args) {
   const mutated = args.collectDirty ? args.collectDirty([]) : collectDirtyForStructural(args.recomputeParentsFrom, []);
@@ -11132,241 +11438,58 @@ function asDate(value) {
   if (value instanceof Date) return value;
   if (typeof value === "string" || typeof value === "number") {
     const parsed2 = new Date(value);
-    return Number.isNaN(parsed2.getTime()) ? null : parsed2;
-  }
-  return null;
-}
-function sameDate(first, second) {
-  if (first === null && second === null) return true;
-  if (first === null || second === null) return false;
-  return first.getTime() === second.getTime();
-}
-
-// src/dispatch/shared/constraint-settle.ts
-async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, revert }) {
-  let { scheduledIds } = await runPostMutation(
-    deps,
-    withCriticalPathSuppressed(postMutationArgs)
-  );
-  let someEditReverted = false;
-  for (const { activityId, priorConstraintDate } of revertTargets) {
-    const reverted = revert(activityId, priorConstraintDate);
-    someEditReverted = someEditReverted || reverted;
-  }
-  if (someEditReverted) {
-    const resettled = await runPostMutation(
-      deps,
-      withCriticalPathSuppressed(postMutationArgs)
-    );
-    scheduledIds = mergeScheduledIds(scheduledIds, resettled.scheduledIds);
-  }
-  if (resolveRunCriticalPath(postMutationArgs.action)) {
-    await runPostMutation(deps, criticalPathOnlyArgs(postMutationArgs));
-  }
-  return { scheduledIds };
-}
-function withCriticalPathSuppressed(args) {
-  return {
-    ...args,
-    options: { ...args.options, skipCriticalPath: true }
-  };
-}
-function criticalPathOnlyArgs(args) {
-  return {
-    action: args.action,
-    autoscheduleFrom: null,
-    recomputeParentsFrom: [],
-    now: null,
-    options: args.options
-  };
-}
-function mergeScheduledIds(firstSettleIds, secondSettleIds) {
-  const merged = new Set(firstSettleIds);
-  for (const scheduledId of secondSettleIds) merged.add(scheduledId);
-  return [...merged];
-}
-
-// src/dispatch/sir-auto-reject.ts
-function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
-  const effects = [];
-  for (const id of touchedIds) {
-    const before = beforeSnap.get(id);
-    if (!before) continue;
-    const pendingRequestIds = before.pendingRequestIds ?? [];
-    if (!isFrozen({ pendingRequestIds })) continue;
-    if (adapter.getActivity(id) != null) continue;
-    for (const pending of pendingRequestIds) {
-      effects.push({
-        kind: SCHEDULE_EFFECT_KIND.SIR_AUTO_REJECT,
-        activityId: id,
-        sirId: pending,
-        reason: SIR_AUTO_REJECT_REASON.ACTIVITY_DELETED
-      });
-    }
-  }
-  return effects;
-}
-
-// src/dispatch/conversion.ts
-function snapshotToLink(l) {
-  const view = {
-    id: String(l.id),
-    source: String(l.source),
-    target: String(l.target),
-    type: l.type,
-    lag: Number(l.lag),
-    freeSlackHours: typeof l.freeSlackHours === "number" && Number.isFinite(l.freeSlackHours) ? l.freeSlackHours : null,
-    isCritical: l.isCritical === true
-  };
-  if (l.proplannerId != null) view.proplannerId = Number(l.proplannerId);
-  if (l.ganttId != null) view.ganttId = Number(l.ganttId);
-  if (l.sectorId != null) view.sectorId = Number(l.sectorId);
-  return view;
-}
-
-// src/dispatch/shared/change-set.ts
-var SIR_DETECTION_PHASE = {
-  BEFORE_DIFF: "before-diff",
-  AFTER_DIFF: "after-diff"
-};
-async function assembleChangeSet(adapter, args) {
-  const allTouched = collectChangeSetIds(adapter, args);
-  const before = new Map(args.beforeSnap);
-  const captured = adapter.peekWriteCapture();
-  if (captured) {
-    const insertedIds = collectInsertedIds(captured);
-    mergeDirtyBeforeImages(adapter, captured, insertedIds, before, allTouched);
-  }
-  const sirDetection = args.sirDetection;
-  const beforeDiffEffects = sirDetection === SIR_DETECTION_PHASE.BEFORE_DIFF ? detectSirAutoReject(before, adapter, allTouched) : [];
-  const correlativeBefore = buildCorrelativeBeforeMap(
-    args.correlativeShifts,
-    allTouched
-  );
-  const activityChanges = await buildActivityChanges(
-    adapter,
-    before,
-    allTouched,
-    correlativeBefore
-  );
-  const effects = sirDetection === SIR_DETECTION_PHASE.AFTER_DIFF ? detectSirAutoReject(before, adapter, allTouched) : beforeDiffEffects;
-  const warnings = args.warnings ?? [];
-  const linkChanges = mergeLinkChanges(
-    args.links ?? [],
-    captured ? buildCapturedCriticalPathLinkChanges(adapter, captured) : []
-  );
-  return {
-    source: args.source,
-    activities: activityChanges,
-    links: linkChanges,
-    calendars: [],
-    trackingEvents: args.trackingEvents ?? [],
-    ...effects.length > 0 ? { effects } : {},
-    ...warnings.length > 0 ? { warnings } : {}
-  };
-}
-function buildCapturedCriticalPathLinkChanges(adapter, captured) {
-  const changes = [];
-  for (const operation of captured.ops) {
-    if (operation.kind !== WRITE_OPERATION_KIND.LINK_FIELD) continue;
-    const after = adapter.getLink(operation.linkId);
-    if (!after) continue;
-    const fields = {};
-    for (const field of ["freeSlackHours", "isCritical"]) {
-      if (!Object.is(operation.before[field], after[field])) {
-        fields[field] = {
-          before: operation.before[field],
-          after: after[field]
-        };
-      }
-    }
-    if (Object.keys(fields).length === 0) continue;
-    changes.push({
-      id: operation.linkId,
-      kind: ENTITY_CHANGE_KIND.UPDATED,
-      fields,
-      after: snapshotToLink(after)
-    });
-  }
-  return changes;
-}
-function mergeLinkChanges(explicit, captured) {
-  const merged = [];
-  const indexById = /* @__PURE__ */ new Map();
-  for (const change of explicit) {
-    const index = indexById.get(change.id);
-    if (index === void 0) {
-      indexById.set(change.id, merged.length);
-      merged.push(change);
-      continue;
-    }
-    const current = merged[index];
-    if ((current.kind === ENTITY_CHANGE_KIND.UPDATED || current.kind === ENTITY_CHANGE_KIND.CREATED) && change.kind === ENTITY_CHANGE_KIND.UPDATED) {
-      merged[index] = {
-        ...current,
-        fields: { ...current.fields, ...change.fields },
-        after: change.after
-      };
-      continue;
-    }
-    merged[index] = change;
-  }
-  for (const change of captured) {
-    const index = indexById.get(change.id);
-    if (index === void 0) {
-      indexById.set(change.id, merged.length);
-      merged.push(change);
-      continue;
-    }
-    const current = merged[index];
-    if (current.kind === ENTITY_CHANGE_KIND.DELETED) continue;
-    const capturedFields = current.kind === ENTITY_CHANGE_KIND.CREATED ? Object.fromEntries(
-      Object.entries(change.fields ?? {}).map(([field, value]) => [
-        field,
-        { before: void 0, after: value.after }
-      ])
-    ) : change.fields;
-    merged[index] = {
-      ...current,
-      fields: { ...current.fields, ...capturedFields },
-      after: change.after
-    };
+    return Number.isNaN(parsed2.getTime()) ? null : parsed2;
   }
-  return merged;
+  return null;
 }
-function buildCorrelativeBeforeMap(shifts, touched) {
-  if (!shifts || shifts.length === 0) return void 0;
-  const correlativeBefore = /* @__PURE__ */ new Map();
-  for (const shift of shifts) {
-    correlativeBefore.set(shift.activityId, shift.before);
-    touched.add(shift.activityId);
-  }
-  return correlativeBefore;
+function sameDate(first, second) {
+  if (first === null && second === null) return true;
+  if (first === null || second === null) return false;
+  return first.getTime() === second.getTime();
 }
-function collectChangeSetIds(adapter, args) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const id of args.touchedIds) ids.add(id);
-  for (const id of args.scheduledIds) ids.add(id);
-  if (args.includeAllIds) {
-    for (const id of adapter.getAllIds()) ids.add(id);
+
+// src/dispatch/shared/constraint-settle.ts
+async function settleConstraintEdits(deps, { postMutationArgs, revertTargets, revert }) {
+  let { scheduledIds } = await runPostMutation(
+    deps,
+    withCriticalPathSuppressed(postMutationArgs)
+  );
+  let someEditReverted = false;
+  for (const { activityId, priorConstraintDate } of revertTargets) {
+    const reverted = revert(activityId, priorConstraintDate);
+    someEditReverted = someEditReverted || reverted;
   }
-  return ids;
-}
-function mergeDirtyBeforeImages(adapter, captured, insertedIds, before, touched) {
-  for (const id of captured.dirty) {
-    if (insertedIds.has(id) || before.has(id)) continue;
-    const beforeImage = captured.before.get(id);
-    const live = adapter.getActivity(id);
-    if (!beforeImage || !live) continue;
-    if (Object.keys(diffActivity(beforeImage, live)).length === 0) continue;
-    before.set(id, beforeImage);
-    touched.add(id);
+  if (someEditReverted) {
+    const resettled = await runPostMutation(
+      deps,
+      withCriticalPathSuppressed(postMutationArgs)
+    );
+    scheduledIds = mergeScheduledIds(scheduledIds, resettled.scheduledIds);
+  }
+  if (resolveRunCriticalPath(postMutationArgs.action)) {
+    await runPostMutation(deps, criticalPathOnlyArgs(postMutationArgs));
   }
+  return { scheduledIds };
 }
-function collectInsertedIds(captured) {
-  return new Set(
-    captured.ops.filter((operation) => operation.kind === WRITE_OPERATION_KIND.INSERT).map((operation) => operation.activityId)
-  );
+function withCriticalPathSuppressed(args) {
+  return {
+    ...args,
+    options: { ...args.options, skipCriticalPath: true }
+  };
+}
+function criticalPathOnlyArgs(args) {
+  return {
+    action: args.action,
+    autoscheduleFrom: null,
+    recomputeParentsFrom: [],
+    now: null,
+    options: args.options
+  };
+}
+function mergeScheduledIds(firstSettleIds, secondSettleIds) {
+  const merged = new Set(firstSettleIds);
+  for (const scheduledId of secondSettleIds) merged.add(scheduledId);
+  return [...merged];
 }
 
 // src/dispatch/shared/helpers.ts
@@ -11445,6 +11568,18 @@ function buildLinkChangesForBatch(applied, beforeLinks, adapter) {
     const afterLink = adapter.getLink(op.linkId);
     if (!afterLink) continue;
     const fields = {};
+    if (beforeLink && String(beforeLink.source) !== String(afterLink.source)) {
+      fields.source = {
+        before: String(beforeLink.source),
+        after: String(afterLink.source)
+      };
+    }
+    if (beforeLink && String(beforeLink.target) !== String(afterLink.target)) {
+      fields.target = {
+        before: String(beforeLink.target),
+        after: String(afterLink.target)
+      };
+    }
     if (beforeLink && beforeLink.type !== afterLink.type) {
       fields.type = { before: beforeLink.type, after: afterLink.type };
     }
@@ -11713,6 +11848,12 @@ function collectBatchContext(operations, adapter) {
     if (!link) continue;
     activityIds.add(String(link.source));
     activityIds.add(String(link.target));
+    if (operation.kind === DISPATCH_LINK_OPERATION_KIND.UPDATE) {
+      if (operation.source !== void 0)
+        activityIds.add(String(operation.source));
+      if (operation.target !== void 0)
+        activityIds.add(String(operation.target));
+    }
     links.set(operation.linkId, { ...link });
   }
   return { activityIds, links };
@@ -11798,6 +11939,8 @@ function batchOpToLinkOperation(op, hoursPerDay) {
     return {
       kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
       linkId: op.linkId,
+      source: op.source,
+      target: op.target,
       type: op.type,
       lag: op.lag === void 0 ? void 0 : lagDaysToHours(op.lag, hoursPerDay)
     };
@@ -11821,8 +11964,11 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
   if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== DISPATCH_ACTION_KIND.INLINE_EDIT) {
     return { ok: false, reason: applied[0].rejected };
   }
+  if (!options.skipAutoSchedule) {
+    snapFreedMilestones(applied, beforeLinks, adapter);
+  }
   const triggerId = pickAutoscheduleTrigger(applied, beforeLinks, adapter);
-  const { scheduledIds } = await runPostMutation(
+  const { scheduledIds, warnings } = await runPostMutation(
     {
       adapter,
       scheduler,
@@ -11860,10 +12006,32 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
       touchedIds: affectedActivityIds,
       scheduledIds,
       links: linkChanges,
+      warnings,
       hoursPerDay: sector.hoursPerDay
     })
   };
 }
+function snapFreedMilestones(applied, beforeLinks, adapter) {
+  for (const operation of applied) {
+    if (operation.rejected !== null || operation.op.kind !== DISPATCH_LINK_OPERATION_KIND.DELETE) {
+      continue;
+    }
+    const targetId = beforeLinks.get(operation.op.linkId)?.target;
+    if (!targetId || adapter.getIncomingLinkIds(targetId).length > 0) continue;
+    const activity = adapter.getActivity(targetId);
+    if (!activity || activity.type !== ACTIVITY_TYPE.MILESTONE) continue;
+    const startDate = adapter.getClosestWorkTime({
+      date: activity.startDate,
+      dir: WORK_TIME_DIRECTION.FUTURE,
+      task: activity
+    });
+    if (startDate.getTime() === activity.startDate.getTime()) continue;
+    adapter.setActivityFields(targetId, {
+      startDate,
+      endDate: new Date(startDate)
+    });
+  }
+}
 function pickAutoscheduleTrigger(applied, beforeLinks, adapter) {
   for (const operation of applied) {
     if (operation.rejected !== null) continue;
@@ -11896,6 +12064,8 @@ function toLinkOperation(action, hoursPerDay) {
     return {
       kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
       linkId: action.linkId,
+      source: action.source,
+      target: action.target,
       type: action.type,
       lag: action.lag === void 0 ? void 0 : lagDaysToHours(action.lag, hoursPerDay)
     };
@@ -14827,6 +14997,158 @@ async function dispatchActivityOutdent(action, options, deps) {
   };
 }
 
+// src/dispatch/handlers/activity-type-set.ts
+async function dispatchActivityTypeSet(action, options, deps) {
+  const { adapter, scheduler, sector } = deps;
+  const activity = adapter.getActivity(action.activityId);
+  if (!activity) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+  }
+  if (!isActivityType(action.type)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  const children = adapter.getChildren(action.activityId);
+  const targetIsProject = action.type === ACTIVITY_TYPE.PROJECT;
+  if (targetIsProject !== children.length > 0) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  const allIds = new Set(adapter.getAllIds());
+  const beforeSnap = await snapshotActivities(adapter, allIds);
+  scheduler.invalidateAllCaches();
+  if (targetIsProject && activity.type !== ACTIVITY_TYPE.PROJECT) {
+    applyPromotion(action.activityId, children[0], deps);
+  } else if (!targetIsProject && activity.type === ACTIVITY_TYPE.PROJECT) {
+    applyDemotion(action.activityId, deps);
+  }
+  if (action.type !== ACTIVITY_TYPE.PROJECT) {
+    applyLeafType(action.activityId, action.type, deps);
+    ensureLeafCustomId(action.activityId, deps);
+  } else {
+    recomputeRollupCascadesForParent(action.activityId, adapter);
+  }
+  const beforeLinks = removeInvalidHierarchyLinks(action.activityId, deps);
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter,
+      scheduler,
+      sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: action.activityId,
+      recomputeParentsFrom: [action.activityId],
+      recomputeParentProgress: true,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds: allIds,
+      scheduledIds,
+      sirDetection: SIR_DETECTION_PHASE.BEFORE_DIFF,
+      links: buildLinkDeletions(beforeLinks),
+      hoursPerDay: sector.hoursPerDay
+    }),
+    __beforeLinks: new Map(beforeLinks)
+  };
+}
+function applyPromotion(activityId, childId, deps) {
+  const activity = deps.adapter.getActivity(activityId);
+  const oldCustomId = activity?.customId ?? null;
+  const promotion = buildParentMutations({
+    parentId: activityId,
+    newChildId: childId,
+    isCurrentlyLeaf: true,
+    getParent: (id) => deps.adapter.getActivity(id) ?? null
+  });
+  if (!promotion) return;
+  for (const [field, value] of Object.entries(promotion.fields)) {
+    setActivityFieldDynamic(deps.adapter, activityId, field, value);
+  }
+  if (promotion.promotionSnapshot) {
+    deps.adapter.setPromotionSnapshot(activityId, promotion.promotionSnapshot);
+  }
+  if (promotion.fields.customId === null) {
+    deps.customIdTracker.releaseCustomId(oldCustomId);
+  }
+}
+function applyDemotion(activityId, deps) {
+  const activity = deps.adapter.getActivity(activityId);
+  if (!activity) return;
+  const demotion = buildParentDemotionMutations({
+    parent: activity,
+    remainingChildIds: [],
+    defaultDurationHours: deps.sector.hoursPerDay,
+    promotionSnapshot: deps.adapter.getPromotionSnapshot(activityId),
+    computeEndDate: (startDate, durationHours) => deps.adapter.calculateEndDate({
+      startDate,
+      durationHours,
+      task: activity
+    })
+  });
+  if (!demotion) return;
+  for (const [field, value] of Object.entries(demotion.fields)) {
+    setActivityFieldDynamic(deps.adapter, activityId, field, value);
+  }
+}
+function applyLeafType(activityId, type, deps) {
+  const activity = deps.adapter.getActivity(activityId);
+  if (!activity) return;
+  deps.adapter.setActivityField(activityId, ACTIVITY_PROPERTY.TYPE, type);
+  const durationHours = type === ACTIVITY_TYPE.MILESTONE ? 0 : activity.durationHours === 0 ? deps.sector.hoursPerDay : activity.durationHours;
+  if (durationHours !== activity.durationHours) {
+    deps.adapter.setActivityField(
+      activityId,
+      ACTIVITY_PROPERTY.DURATION_HOURS,
+      durationHours
+    );
+  }
+  const current = deps.adapter.getActivity(activityId);
+  if (!current) return;
+  const endDate = deps.adapter.calculateEndDate({
+    startDate: current.startDate,
+    durationHours,
+    task: current
+  });
+  deps.adapter.setActivityField(
+    activityId,
+    ACTIVITY_PROPERTY.END_DATE,
+    endDate
+  );
+}
+function ensureLeafCustomId(activityId, deps) {
+  const activity = deps.adapter.getActivity(activityId);
+  if (activity?.customId) return;
+  const previousSiblingId = findPrevSiblingHelper(activityId, deps.adapter);
+  const previousCustomId = previousSiblingId ? deps.adapter.getActivity(previousSiblingId)?.customId : null;
+  const generated = deps.customIdTracker.generateCustomIdForRestoredChild(
+    previousCustomId || null
+  );
+  deps.adapter.setActivityField(
+    activityId,
+    ACTIVITY_PROPERTY.CUSTOM_ID,
+    generated
+  );
+}
+function removeInvalidHierarchyLinks(activityId, deps) {
+  const beforeLinks = /* @__PURE__ */ new Map();
+  for (const linkId of collectInvalidLinkIdsForCycle(
+    [activityId],
+    deps.adapter
+  )) {
+    const link = deps.adapter.getLink(linkId);
+    if (!link) continue;
+    beforeLinks.set(String(linkId), { ...link });
+    deps.adapter.removeLink(linkId);
+  }
+  return beforeLinks;
+}
+
 // src/dispatch/handlers/set-progress.ts
 async function dispatchActivitySetProgress(action, options, deps) {
   const { adapter, ctx, scheduler, sector } = deps;
@@ -16145,6 +16467,9 @@ async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT) {
     return dispatchActivityOutdent(action, options, deps);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_TYPE_SET) {
+    return dispatchActivityTypeSet(action, options, deps);
+  }
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS) {
     return dispatchActivitySetProgress(action, options, deps);
   }
@@ -16181,6 +16506,9 @@ async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_CONVERT) {
     return dispatchActivityLookaheadConvert(action, options, deps);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.SCHEDULE_AUTO_SCHEDULE) {
+    return dispatchScheduleAutoSchedule(action, options, deps);
+  }
   if (action.kind === DISPATCH_ACTION_KIND.INLINE_EDIT && (action.column === COLUMN.CUSTOM_PREDECESSORS || action.column === COLUMN.CUSTOM_SUCESSORS)) {
     return dispatchInlineEditLinks(action, options, deps);
   }
@@ -19594,16 +19922,59 @@ var ScheduleState = class _ScheduleState {
     if (incoming)
       this._incoming.set(String(link.target), detachLinkRef(incoming, link.id));
   }
+  _removeLinkRef(index, activityId, linkId) {
+    const refs = index.get(activityId);
+    if (refs) index.set(activityId, detachLinkRef(refs, linkId));
+  }
+  _insertLinkRefInOrder(index, activityId, linkId) {
+    const precedingIds = /* @__PURE__ */ new Set();
+    for (const existingId of this._links.keys()) {
+      if (String(existingId) === String(linkId)) break;
+      precedingIds.add(String(existingId));
+    }
+    const refs = [...index.get(activityId) ?? []];
+    const insertionIndex = refs.findIndex(
+      (existingId) => !precedingIds.has(String(existingId))
+    );
+    refs.splice(insertionIndex < 0 ? refs.length : insertionIndex, 0, linkId);
+    index.set(activityId, refs);
+  }
   setLinkField(linkId, field, value) {
     const link = this.getLink(linkId);
     if (!link) return;
     this._writeCapture.noteLinkField(String(linkId), link);
     link[field] = value;
   }
+  setLinkEndpoints(linkId, source, target) {
+    const link = this.getLink(linkId);
+    if (!link) return;
+    const sourceChanged = String(link.source) !== String(source);
+    const targetChanged = String(link.target) !== String(target);
+    if (!sourceChanged && !targetChanged) return;
+    this._writeCapture.noteLinkField(String(linkId), link);
+    if (sourceChanged) {
+      this._removeLinkRef(this._outgoing, String(link.source), link.id);
+      link.source = source;
+      this._insertLinkRefInOrder(this._outgoing, String(source), link.id);
+    }
+    if (targetChanged) {
+      this._removeLinkRef(this._incoming, String(link.target), link.id);
+      link.target = target;
+      this._insertLinkRefInOrder(this._incoming, String(target), link.id);
+    }
+  }
   setLinkFieldDynamic(linkId, field, value) {
-    if (!isMutableLinkField(field)) return;
     const link = this.getLink(linkId);
     if (!link) return;
+    if (field === LINK_PROPERTY.SOURCE) {
+      this.setLinkEndpoints(linkId, String(value), link.target);
+      return;
+    }
+    if (field === LINK_PROPERTY.TARGET) {
+      this.setLinkEndpoints(linkId, link.source, String(value));
+      return;
+    }
+    if (!isMutableLinkField(field)) return;
     this._writeCapture.noteLinkField(String(linkId), link);
     Reflect.set(link, field, value);
   }
@@ -19724,10 +20095,16 @@ var ScheduleState = class _ScheduleState {
       }
   }
   _restoreLinkFields(ops) {
-    for (const op of ops)
-      if (op.kind === WRITE_OPERATION_KIND.LINK_FIELD && this._links.has(op.linkId)) {
-        this._links.set(op.linkId, op.before);
+    for (const op of ops) {
+      if (op.kind !== WRITE_OPERATION_KIND.LINK_FIELD) continue;
+      const live = this._links.get(op.linkId);
+      if (!live) continue;
+      this.setLinkEndpoints(op.linkId, op.before.source, op.before.target);
+      for (const key of Object.keys(live)) {
+        if (!Object.hasOwn(op.before, key)) Reflect.deleteProperty(live, key);
       }
+      Object.assign(live, op.before);
+    }
   }
   _restoreActivityFields(before) {
     for (const [id, snapshot] of before) {
@@ -20198,18 +20575,23 @@ function applyChangeSetSide(state, entry, side) {
   for (const ch of cs.links) {
     if (ch.kind === ENTITY_CHANGE_KIND.UPDATED) {
       if (!ch.fields) continue;
-      if (Object.hasOwn(ch.fields, "source") || Object.hasOwn(ch.fields, "target")) {
-        const snapshot = side === CHANGE_SET_SIDE.BEFORE ? entry.beforeLinks?.get(String(ch.id)) : entry.afterLinks?.get(String(ch.id));
-        if (!snapshot) {
-          throw new Error(
-            `${side === CHANGE_SET_SIDE.BEFORE ? "undo" : "redo"}: missing link snapshot for ${ch.id}`
-          );
-        }
-        state.removeLink(String(ch.id));
-        state.addLink({ ...snapshot });
-        continue;
+      const liveLink = state.getLink(String(ch.id));
+      const sourceChange = ch.fields[LINK_PROPERTY.SOURCE];
+      const targetChange = ch.fields[LINK_PROPERTY.TARGET];
+      if (liveLink && (sourceChange || targetChange)) {
+        state.setLinkEndpoints(
+          String(ch.id),
+          String(
+            sourceChange ? side === CHANGE_SET_SIDE.BEFORE ? sourceChange.before : sourceChange.after : liveLink.source
+          ),
+          String(
+            targetChange ? side === CHANGE_SET_SIDE.BEFORE ? targetChange.before : targetChange.after : liveLink.target
+          )
+        );
       }
       for (const [field, fv] of Object.entries(ch.fields)) {
+        if (field === LINK_PROPERTY.SOURCE || field === LINK_PROPERTY.TARGET)
+          continue;
         setLinkFieldDynamic(
           state,
           String(ch.id),
@@ -22772,6 +23154,15 @@ function evaluateEnd(formula, proposedEdgeTimeMs) {
 
 // src/init/schedule-core.ts
 var FORK_SOURCE = /* @__PURE__ */ Symbol("ScheduleCore.fork.source");
+function emptyChangeSet(source) {
+  return {
+    source,
+    activities: [],
+    links: [],
+    calendars: [],
+    trackingEvents: []
+  };
+}
 function acknowledgesPersistence(action) {
   return action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true;
 }
@@ -23297,15 +23688,20 @@ var ScheduleCore = class _ScheduleCore {
   createProjectionChangeSetFrom(source) {
     this.assertReady();
     source.assertReady();
-    const projectionOf = (core) => ({
-      activities: core.getAllActivitiesView(),
-      links: core.getAllLinksView(),
-      calendars: core.getAllCalendars(),
-      selectedIds: core.getSelectedActivityIds(),
-      hiddenIds: core.getHiddenActivityIds(),
-      order: collectBranchOrder(core.coreRuntime.state)
-    });
-    return createProjectionChangeSet(projectionOf(this), projectionOf(source));
+    return createProjectionChangeSet(
+      this._snapshotProjection(),
+      source._snapshotProjection()
+    );
+  }
+  _snapshotProjection() {
+    return {
+      activities: this.getAllActivitiesView(),
+      links: this.getAllLinksView(),
+      calendars: this.getAllCalendars(),
+      selectedIds: this.getSelectedActivityIds(),
+      hiddenIds: this.getHiddenActivityIds(),
+      order: collectBranchOrder(this.coreRuntime.state)
+    };
   }
   /** @returns Deleted persisted activity identities since the last save. */
   getDeletedActivitiesSinceLastSave() {
@@ -23367,6 +23763,17 @@ var ScheduleCore = class _ScheduleCore {
     const admitted = this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
+  /**
+   * Applies commands in order and runs deferred scheduling finalization once.
+   *
+   * Rejected commands do not roll back earlier accepted commands.
+   */
+  async dispatchMany(actions, options = {}) {
+    const admitted = actions.some(dispatchChangesSchedulingState) ? this._admitScheduleMutation() : false;
+    return this._enqueue(
+      () => this._dispatchManyInner(actions, options, admitted)
+    );
+  }
   /**
    * Serializes and applies an activity creation batch.
    *
@@ -23404,7 +23811,125 @@ var ScheduleCore = class _ScheduleCore {
       this._settleScheduleMutation(admitted, changedState);
     }
   }
-  async _runDispatch(action, options) {
+  async _dispatchManyInner(actions, options, admitted) {
+    const projectionBefore = this._snapshotProjection();
+    const deferredOptions = {
+      ...options,
+      skipAutoSchedule: true,
+      skipCriticalPath: true
+    };
+    const results = [];
+    const acceptedChangeSets = [];
+    const acceptedActions = [];
+    let changedSchedulingState = false;
+    let finalizationRequested = false;
+    let scopedActivityId;
+    let requiresRootFinalization = false;
+    let finalizationChangeSet = null;
+    let autoScheduled = false;
+    let completed = false;
+    try {
+      for (const action of actions) {
+        if (action.kind === DISPATCH_ACTION_KIND.SCHEDULE_AUTO_SCHEDULE) {
+          if (action.activityId !== void 0 && !this.coreRuntime.state.activityExists(action.activityId)) {
+            results.push({
+              ok: false,
+              reason: REJECTION_REASON.ACTIVITY_NOT_FOUND
+            });
+            continue;
+          }
+          const changes = emptyChangeSet(action);
+          results.push({ ok: true, changes });
+          acceptedChangeSets.push(changes);
+          acceptedActions.push(action);
+          finalizationRequested = true;
+          if (action.activityId === void 0 || scopedActivityId !== void 0 && scopedActivityId !== action.activityId) {
+            requiresRootFinalization = true;
+          } else {
+            scopedActivityId = action.activityId;
+          }
+          continue;
+        }
+        const dispatched = await this._runDispatch(
+          action,
+          deferredOptions,
+          true
+        );
+        results.push(dispatched.result);
+        if (dispatched.result.ok) {
+          acceptedChangeSets.push(dispatched.result.changes);
+          acceptedActions.push(action);
+        }
+        if (dispatched.changedState) {
+          changedSchedulingState = true;
+          finalizationRequested = true;
+          requiresRootFinalization = true;
+        }
+      }
+      if (finalizationRequested) {
+        const finalizationAction = requiresRootFinalization || scopedActivityId === void 0 ? { kind: DISPATCH_ACTION_KIND.SCHEDULE_AUTO_SCHEDULE } : {
+          kind: DISPATCH_ACTION_KIND.SCHEDULE_AUTO_SCHEDULE,
+          activityId: scopedActivityId
+        };
+        const finalized = await this._runDispatch(
+          finalizationAction,
+          options,
+          true
+        );
+        if (finalized.result.ok) {
+          finalizationChangeSet = finalized.result.changes;
+          acceptedChangeSets.push(finalized.result.changes);
+          autoScheduled = options.skipAutoSchedule !== true;
+        }
+        changedSchedulingState ||= finalized.changedState;
+      }
+      if (changedSchedulingState) {
+        this._recordScheduleMutation(
+          finalizationChangeSet !== null && options.skipAutoSchedule !== true && options.skipCriticalPath !== true
+        );
+      }
+      completed = true;
+      return {
+        results,
+        autoScheduled,
+        changeSet: this._aggregateDispatchManyChangeSets(
+          projectionBefore,
+          acceptedChangeSets,
+          acceptedActions
+        )
+      };
+    } finally {
+      if (!completed && changedSchedulingState) {
+        this._recordScheduleMutation(false);
+      }
+      this._settleScheduleMutation(
+        admitted,
+        completed && changedSchedulingState
+      );
+    }
+  }
+  _aggregateDispatchManyChangeSets(before, changeSets, acceptedActions) {
+    if (changeSets.length === 0) return null;
+    const aggregate = createProjectionChangeSet(
+      this._snapshotProjection(),
+      before
+    );
+    const effects = changeSets.flatMap((changes) => changes.effects ?? []);
+    const warnings = changeSets.flatMap((changes) => changes.warnings ?? []);
+    return {
+      ...aggregate,
+      source: {
+        kind: CHANGE_SET_SOURCE_KIND.DISPATCH_MANY,
+        actions: acceptedActions
+      },
+      trackingEvents: changeSets.flatMap(
+        (changes) => changes.trackingEvents
+      ),
+      ...effects.length === 0 ? {} : { effects },
+      ...warnings.length === 0 ? {} : { warnings }
+    };
+  }
+  async _runDispatch(action, options, deferScheduleRevision = false) {
     this.assertReady();
     if (this._isFork && acknowledgesPersistence(action)) {
       return {
@@ -23533,9 +24058,11 @@ var ScheduleCore = class _ScheduleCore {
     const hasSubstantiveChanges = changeSetIsSubstantive(result.changes);
     if (hasSubstantiveChanges) this._stateRevision++;
     if (dispatchChangesSchedulingState(action) && hasSubstantiveChanges) {
-      this._recordScheduleMutation(
-        options.skipAutoSchedule !== true && options.skipCriticalPath !== true && resolveRunCriticalPath(action)
-      );
+      if (!deferScheduleRevision) {
+        this._recordScheduleMutation(
+          options.skipAutoSchedule !== true && options.skipCriticalPath !== true && resolveRunCriticalPath(action)
+        );
+      }
       return { result: toPublicDispatchResult(result), changedState: true };
     }
     return { result: toPublicDispatchResult(result), changedState: false };