@outbuild-company/schedule-core 1.10.4 → 1.12.0

package/dist/index.cjs

@@ -1,5 +1,681 @@
 'use strict';
 
+// src/types.ts
+var WORK_TIME_DIRECTION = {
+  FUTURE: "future",
+  PAST: "past"
+};
+var CALENDAR_UNIT = {
+  HOUR: "hour",
+  DAY: "day"
+};
+var ACTIVITY_PONDERATOR_CRITERION = {
+  DURATION: "DURATION",
+  COST: "COST",
+  WORK_HOURS: "HH"
+};
+var STATUS_CRITERIA = {
+  BASELINE: "Baseline",
+  ACTUAL: "Actual"
+};
+var STATUS = {
+  DONE: "Done",
+  OVERDUE: "Overdue",
+  ADVANCEMENT: "Advancement",
+  WAITING: "Waiting",
+  DOING: "Doing"
+};
+
+// src/constraints/index.ts
+var CONSTRAINT_TYPE = {
+  ASAP: "asap",
+  ALAP: "alap",
+  SNET: "snet",
+  SNLT: "snlt",
+  FNET: "fnet",
+  FNLT: "fnlt",
+  MSO: "mso",
+  MFO: "mfo"
+};
+var VIOLATION_RULES = {
+  mso: () => true,
+  mfo: () => true,
+  snlt: (constraint, projected) => constraint < projected,
+  snet: (constraint, projected) => constraint > projected,
+  fnlt: (constraint, projected) => constraint < projected,
+  fnet: (constraint, projected) => constraint > projected
+};
+function checkConstraintViolation(constraintType, constraintDate, projectedDate) {
+  if (!constraintDate) return { violated: false };
+  const rule = VIOLATION_RULES[constraintType];
+  if (!rule) return { violated: false };
+  if (rule(constraintDate, projectedDate)) {
+    return { violated: true, constraintType, constraintDate };
+  }
+  return { violated: false };
+}
+var START_BASED_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "mso",
+  "snet",
+  "snlt"
+]);
+function pickProjectedDateForConstraint(constraintType, projectedStart, projectedEnd) {
+  return START_BASED_CONSTRAINTS.has(constraintType) ? projectedStart : projectedEnd;
+}
+function buildConstraintNotification(constraintType, constraintDate, projectedDate) {
+  return {
+    type: "constraint",
+    messageKey: "constraint_violation",
+    data: {
+      constraintType,
+      constraintDate,
+      ...projectedDate ? { projectedDate } : {}
+    }
+  };
+}
+var CONSTRAINT_CASES = {
+  snet: { startOfDay: true, direction: WORK_TIME_DIRECTION.FUTURE },
+  snlt: { startOfDay: true, direction: WORK_TIME_DIRECTION.PAST },
+  fnet: { startOfDay: false, direction: WORK_TIME_DIRECTION.FUTURE },
+  fnlt: { startOfDay: false, direction: WORK_TIME_DIRECTION.PAST },
+  mso: { startOfDay: true, direction: WORK_TIME_DIRECTION.FUTURE },
+  mfo: { startOfDay: false, direction: WORK_TIME_DIRECTION.PAST }
+};
+var startOfUtcDay = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+var addUtcDays = (d, n) => new Date(d.getTime() + n * 864e5);
+var sameUtcDay = (a, b) => a.getUTCFullYear() === b.getUTCFullYear() && a.getUTCMonth() === b.getUTCMonth() && a.getUTCDate() === b.getUTCDate();
+function getEffectiveConstraintDate(activity, adapter) {
+  if (!activity.constraintDate || !activity.constraintType) return null;
+  const config = CONSTRAINT_CASES[activity.constraintType];
+  if (!config) return activity.constraintDate;
+  const cd = activity.constraintDate;
+  const firstWorkOfDay = adapter.getClosestWorkTime({
+    date: startOfUtcDay(cd),
+    dir: WORK_TIME_DIRECTION.FUTURE,
+    task: activity
+  });
+  if (sameUtcDay(firstWorkOfDay, cd)) {
+    if (cd.getTime() !== startOfUtcDay(cd).getTime()) return cd;
+    if (config.startOfDay) return firstWorkOfDay;
+    return adapter.getClosestWorkTime({
+      date: addUtcDays(startOfUtcDay(cd), 1),
+      dir: WORK_TIME_DIRECTION.PAST,
+      task: activity
+    });
+  }
+  const effectiveMidnight = startOfUtcDay(
+    adapter.getClosestWorkTime({
+      date: cd,
+      dir: config.direction,
+      task: activity
+    })
+  );
+  if (config.startOfDay) {
+    return adapter.getClosestWorkTime({
+      date: effectiveMidnight,
+      dir: WORK_TIME_DIRECTION.FUTURE,
+      task: activity
+    });
+  }
+  return adapter.getClosestWorkTime({
+    date: addUtcDays(effectiveMidnight, 1),
+    dir: WORK_TIME_DIRECTION.PAST,
+    task: activity
+  });
+}
+function computeConstraintBounds(activity, adapter) {
+  const empty = {
+    earliestStart: null,
+    latestStart: null,
+    earliestEnd: null,
+    latestEnd: null
+  };
+  const type = activity.constraintType;
+  if (!type || type === "asap" || type === "alap") return empty;
+  const constraintDate = getEffectiveConstraintDate(activity, adapter);
+  if (!constraintDate) return empty;
+  const endFromStart = (start) => adapter.calculateEndDate({
+    startDate: start,
+    durationHours: activity.durationHours,
+    task: activity
+  });
+  const startFromEnd = (end) => adapter.calculateEndDate({
+    startDate: end,
+    durationHours: -activity.durationHours,
+    task: activity
+  });
+  switch (type) {
+    case "snet":
+      return {
+        earliestStart: constraintDate,
+        latestStart: null,
+        earliestEnd: endFromStart(constraintDate),
+        latestEnd: null
+      };
+    case "snlt":
+      return {
+        earliestStart: null,
+        latestStart: constraintDate,
+        earliestEnd: null,
+        latestEnd: endFromStart(constraintDate)
+      };
+    case "fnet":
+      return {
+        earliestStart: startFromEnd(constraintDate),
+        latestStart: null,
+        earliestEnd: constraintDate,
+        latestEnd: null
+      };
+    case "fnlt":
+      return {
+        earliestStart: null,
+        latestStart: startFromEnd(constraintDate),
+        earliestEnd: null,
+        latestEnd: constraintDate
+      };
+    case "mso": {
+      const end = endFromStart(constraintDate);
+      return {
+        earliestStart: constraintDate,
+        latestStart: constraintDate,
+        earliestEnd: end,
+        latestEnd: end
+      };
+    }
+    case "mfo": {
+      const start = startFromEnd(constraintDate);
+      return {
+        earliestStart: start,
+        latestStart: start,
+        earliestEnd: constraintDate,
+        latestEnd: constraintDate
+      };
+    }
+    default:
+      return empty;
+  }
+}
+function isStartWithinBounds(start, bounds) {
+  if (bounds.earliestStart && start < bounds.earliestStart) return false;
+  if (bounds.latestStart && start > bounds.latestStart) return false;
+  return true;
+}
+function clampStartToBounds(candidate, bounds) {
+  if (bounds.latestStart && candidate > bounds.latestStart) {
+    return bounds.latestStart;
+  }
+  if (bounds.earliestStart && candidate < bounds.earliestStart) {
+    return bounds.earliestStart;
+  }
+  return candidate;
+}
+
+// src/autoscheduler/types.ts
+var LINK_TYPE = {
+  FINISH_TO_START: "0",
+  START_TO_START: "1",
+  FINISH_TO_FINISH: "2",
+  START_TO_FINISH: "3"
+};
+
+// src/constants/columns.ts
+var EDITABLE = {
+  TEXT: "text",
+  DESCRIPTION: "description",
+  DURATION: "duration",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "used_cost",
+  HH_WORK_TIME: "hhWorkTime",
+  START_DATE: "start_date",
+  END_DATE: "end_date",
+  CONSTRAINT_TYPE: "constraint_type",
+  CONSTRAINT_DATE: "constraint_date",
+  CALENDAR_ID: "calendar_id",
+  CUSTOM_ID: "custom_id",
+  SUBCONTRACT_ID: "subcontractId",
+  RESPONSABLES: "responsables",
+  TAGS: "tags",
+  CUSTOM_PREDECESSORS: "custom_predecessors",
+  CUSTOM_SUCESSORS: "custom_sucessors"
+};
+var READ_ONLY = {
+  REAL_WORK: "real_work",
+  REAL_COST: "real_cost",
+  EXPECTED_PROGRESS: "expected_progress",
+  EXPECTED_PROGRESS_BASE: "expected_progress_base",
+  START_BASE: "start_base",
+  END_BASE: "end_base",
+  DURATION_BASE: "duration_base",
+  COST_BASE: "cost_base",
+  WORK_BASE: "work_base",
+  CALENDAR_DURATION: "calendarDuration",
+  IS_CRITICAL: "is_critical",
+  EARLY_START: "earlyStart",
+  EARLY_FINISH: "earlyFinish",
+  LATE_START: "lateStart",
+  LATE_FINISH: "lateFinish",
+  FREE_SLACK: "freeSlack",
+  TOTAL_SLACK: "totalSlack",
+  CORRELATIVE_ID: "correlative_id",
+  UNIQUE_CORRELATIVE_ID: "unique_correlative_id",
+  PONDERATOR: "ponderator",
+  STATUS: "status"
+};
+var COLUMN = { ...EDITABLE, ...READ_ONLY };
+
+// src/autoscheduler/links/types.ts
+var LINK_OPERATION_KIND = {
+  CREATE: "create",
+  UPDATE: "update",
+  DELETE: "delete"
+};
+var LINK_REJECTION_REASON = {
+  SELF_LINK: "self-link",
+  CYCLE: "cycle",
+  DUPLICATE: "duplicate",
+  ACTIVITY_MISSING: "activity-missing",
+  LINK_MISSING: "link-missing",
+  HIERARCHY_LINK: "hierarchy-link"
+};
+
+// src/dispatch/action-kinds.ts
+var DISPATCH_ACTION_KIND = {
+  ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear",
+  ACTIVITY_COPY: "activity-copy",
+  CALENDAR_RECONCILE: "calendar-reconcile",
+  ACTIVITY_PASTE_COPIED: "activity-paste-copied",
+  PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
+  BASELINE_APPLY: "baseline-apply",
+  PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
+  STATUS_CRITERIA_SET: "status-criteria-set",
+  INLINE_EDIT: "inline-edit",
+  DATES_BATCH: "dates-batch",
+  BULK_EDIT: "bulk-edit",
+  LINK_CREATE: "link-create",
+  LINK_UPDATE: "link-update",
+  LINK_DELETE: "link-delete",
+  LINKS_BATCH: "links-batch",
+  ACTIVITY_CREATE: "activity-create",
+  ACTIVITY_DELETE: "activity-delete",
+  ACTIVITY_MOVE: "activity-move",
+  ACTIVITY_INDENT: "activity-indent",
+  ACTIVITY_OUTDENT: "activity-outdent",
+  ACTIVITY_SET_PROGRESS: "activity-set-progress",
+  SELECTION_TOGGLE: "selection-toggle",
+  SELECTION_REPLACE: "selection-replace",
+  VISIBILITY_SET: "visibility-set",
+  FILTER_SET: "filter-set",
+  SORT_SET: "sort-set",
+  SIR_SYNC: "sir-sync",
+  ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
+};
+var ACTIVITY_BATCH_ACTION_KIND = "activity-batch";
+var DISPATCH_LINK_OPERATION_KIND = LINK_OPERATION_KIND;
+var DISPATCH_ACTION_KINDS = Object.values(DISPATCH_ACTION_KIND);
+
+// src/propagations/shared/get-active-baseline.ts
+function getActiveBaseline(activity) {
+  const points = activity?.baselinePoints;
+  if (!Array.isArray(points) || points.length === 0) return null;
+  return points.find((point) => point.isActiveVersion) ?? null;
+}
+
+// src/api/types.ts
+var ACTIVITY_FIELD = {
+  NAME: "name",
+  DESCRIPTION: "description",
+  DURATION_DAYS: "durationDays",
+  PROGRESS: "progress",
+  COST: "cost",
+  USED_COST: "usedCost",
+  WORK_HOURS: "workHours",
+  START_DATE: "startDate",
+  END_DATE: "endDate",
+  CONSTRAINT_TYPE: "constraintType",
+  CONSTRAINT_DATE: "constraintDate",
+  CALENDAR_ID: "calendarId",
+  CUSTOM_ID: "customId",
+  SUBCONTRACT_ID: "subcontractId",
+  RESPONSABLE_IDS: "responsableIds",
+  TAG_IDS: "tagIds"
+};
+var ACTIVITY_DATE_EDGE = {
+  START: "start",
+  END: "end"
+};
+var LINK_RELATIONSHIP = {
+  FINISH_TO_START: "finish-to-start",
+  START_TO_START: "start-to-start",
+  FINISH_TO_FINISH: "finish-to-finish",
+  START_TO_FINISH: "start-to-finish"
+};
+var LINK_BATCH_OPERATION_KIND = {
+  CREATE: "create",
+  UPDATE: "update",
+  REMOVE: "remove"
+};
+
+// src/api/activity-fields.ts
+var ACTIVITY_EDIT_COLUMNS = {
+  [ACTIVITY_FIELD.NAME]: COLUMN.TEXT,
+  [ACTIVITY_FIELD.DESCRIPTION]: COLUMN.DESCRIPTION,
+  [ACTIVITY_FIELD.DURATION_DAYS]: COLUMN.DURATION,
+  [ACTIVITY_FIELD.PROGRESS]: COLUMN.PROGRESS,
+  [ACTIVITY_FIELD.COST]: COLUMN.COST,
+  [ACTIVITY_FIELD.USED_COST]: COLUMN.USED_COST,
+  [ACTIVITY_FIELD.WORK_HOURS]: COLUMN.HH_WORK_TIME,
+  [ACTIVITY_FIELD.START_DATE]: COLUMN.START_DATE,
+  [ACTIVITY_FIELD.END_DATE]: COLUMN.END_DATE,
+  [ACTIVITY_FIELD.CONSTRAINT_TYPE]: COLUMN.CONSTRAINT_TYPE,
+  [ACTIVITY_FIELD.CONSTRAINT_DATE]: COLUMN.CONSTRAINT_DATE,
+  [ACTIVITY_FIELD.CALENDAR_ID]: COLUMN.CALENDAR_ID,
+  [ACTIVITY_FIELD.CUSTOM_ID]: COLUMN.CUSTOM_ID,
+  [ACTIVITY_FIELD.SUBCONTRACT_ID]: COLUMN.SUBCONTRACT_ID,
+  [ACTIVITY_FIELD.RESPONSABLE_IDS]: COLUMN.RESPONSABLES,
+  [ACTIVITY_FIELD.TAG_IDS]: COLUMN.TAGS
+};
+function activityEditToColumnEdit(activityId, edit) {
+  return {
+    activityId,
+    column: ACTIVITY_EDIT_COLUMNS[edit.field],
+    newValue: edit.value
+  };
+}
+
+// src/api/schedule-api.ts
+var LINK_TYPES = {
+  [LINK_RELATIONSHIP.FINISH_TO_START]: LINK_TYPE.FINISH_TO_START,
+  [LINK_RELATIONSHIP.START_TO_START]: LINK_TYPE.START_TO_START,
+  [LINK_RELATIONSHIP.FINISH_TO_FINISH]: LINK_TYPE.FINISH_TO_FINISH,
+  [LINK_RELATIONSHIP.START_TO_FINISH]: LINK_TYPE.START_TO_FINISH
+};
+function linkType(relationship) {
+  return LINK_TYPES[relationship];
+}
+function batchLink(operation) {
+  if (operation.kind === LINK_BATCH_OPERATION_KIND.CREATE) {
+    return {
+      kind: DISPATCH_LINK_OPERATION_KIND.CREATE,
+      source: operation.sourceId,
+      target: operation.targetId,
+      type: linkType(operation.relationship),
+      ...operation.lagDays === void 0 ? {} : { lag: operation.lagDays },
+      ...operation.linkId === void 0 ? {} : { linkId: operation.linkId }
+    };
+  }
+  if (operation.kind === LINK_BATCH_OPERATION_KIND.UPDATE) {
+    return {
+      kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
+      linkId: operation.linkId,
+      ...operation.relationship === void 0 ? {} : { type: linkType(operation.relationship) },
+      ...operation.lagDays === void 0 ? {} : { lag: operation.lagDays }
+    };
+  }
+  if (operation.kind === LINK_BATCH_OPERATION_KIND.REMOVE) {
+    return {
+      kind: DISPATCH_LINK_OPERATION_KIND.DELETE,
+      linkId: operation.linkId
+    };
+  }
+  return operation;
+}
+function activityDateColumn(edge) {
+  if (edge === ACTIVITY_DATE_EDGE.START) return COLUMN.START_DATE;
+  if (edge === ACTIVITY_DATE_EDGE.END) return COLUMN.END_DATE;
+  return edge;
+}
+function activityBatch(input) {
+  return {
+    kind: ACTIVITY_BATCH_ACTION_KIND,
+    mode: input.mode,
+    items: input.items,
+    links: input.links.map((link) => ({
+      source: link.source,
+      target: link.target,
+      type: linkType(link.relationship),
+      ...link.lagDays === void 0 ? {} : { lag: link.lagDays },
+      ...link.linkId === void 0 ? {} : { linkId: link.linkId }
+    })),
+    ...input.eventSource === void 0 ? {} : { eventSource: input.eventSource }
+  };
+}
+function createActivitiesApi(engine) {
+  return {
+    get: (id) => engine.getActivityView(id),
+    list: () => engine.getAllActivitiesView(),
+    ids: () => engine.getAllIds(),
+    forEachId: (visit) => engine.forEachActivityId(visit),
+    property: (id, property) => engine.getProperty(id, property),
+    children: (parentId) => engine.getChildrenView(parentId),
+    childIds: (parentId) => engine.getChildrenIds(parentId),
+    hasChildren: (parentId) => engine.hasChild(parentId),
+    indentTargetParentIds: (ids) => engine.getIndentTargetParentIds(ids),
+    isCustomIdInUse: (customId, currentCustomId) => engine.isCustomIdInUse(customId, currentCustomId ?? null),
+    create: (input, options) => engine.dispatch(
+      { ...input, kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE },
+      options
+    ),
+    applyBatch: (input, options) => engine.applyActivityBatch(activityBatch(input), options),
+    editInline: (activityId, edit, options) => engine.dispatch(
+      {
+        ...activityEditToColumnEdit(activityId, edit),
+        kind: DISPATCH_ACTION_KIND.INLINE_EDIT
+      },
+      options
+    ),
+    applyDragBatch: (edits, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.DATES_BATCH,
+        edits: edits.map((edit) => ({
+          activityId: edit.activityId,
+          column: activityDateColumn(edit.edge),
+          newValue: edit.value
+        }))
+      },
+      options
+    ),
+    editFields: (edits, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.BULK_EDIT,
+        edits: edits.map(
+          (edit) => activityEditToColumnEdit(edit.activityId, edit)
+        )
+      },
+      options
+    ),
+    remove: (activityIds, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_DELETE,
+      activityIds
+    }),
+    move: (input, options) => engine.dispatch(
+      { ...input, kind: DISPATCH_ACTION_KIND.ACTIVITY_MOVE },
+      options
+    ),
+    indent: (activityIds, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_INDENT,
+      activityIds
+    }),
+    outdent: (activityIds, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT,
+      activityIds
+    }),
+    setProgress: (activityId, progress, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS,
+      activityId,
+      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 }
+    }),
+    clearClipboard: (context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR
+    }),
+    lookaheadSync: (input) => engine.dispatch({
+      ...input,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC
+    }),
+    createDateGesturePreview: (gesture) => engine.createDateGesturePreview(gesture)
+  };
+}
+function createLinksApi(engine) {
+  return {
+    get: (id) => engine.getLinkView(id),
+    list: () => engine.getAllLinksView(),
+    forActivity: (activityId) => engine.getLinksForActivityView(activityId),
+    create: (input, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.LINK_CREATE,
+        source: input.sourceId,
+        target: input.targetId,
+        type: linkType(input.relationship),
+        ...input.lagDays === void 0 ? {} : { lag: input.lagDays },
+        ...input.linkId === void 0 ? {} : { linkId: input.linkId }
+      },
+      options
+    ),
+    update: (linkId, patch, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.LINK_UPDATE,
+        linkId,
+        ...patch.relationship === void 0 ? {} : { type: linkType(patch.relationship) },
+        ...patch.lagDays === void 0 ? {} : { lag: patch.lagDays }
+      },
+      options
+    ),
+    remove: (linkId, options) => engine.dispatch(
+      { kind: DISPATCH_ACTION_KIND.LINK_DELETE, linkId },
+      options
+    ),
+    batch: (operations, options) => engine.dispatch(
+      {
+        kind: DISPATCH_ACTION_KIND.LINKS_BATCH,
+        operations: operations.map(batchLink)
+      },
+      options
+    )
+  };
+}
+function createScheduleNamespaces(engine) {
+  const applyBaselinePoints2 = (points, options) => engine.dispatch(
+    { kind: DISPATCH_ACTION_KIND.BASELINE_APPLY, points },
+    options
+  );
+  return {
+    activities: createActivitiesApi(engine),
+    links: createLinksApi(engine),
+    calendars: {
+      get: (id) => engine.getCalendar(id),
+      list: () => engine.getAllCalendars(),
+      listBase: () => engine.getBaseCalendars(),
+      projectWorkHours: () => engine.getProjectWorkHours(),
+      reconcile: (options) => engine.dispatch(
+        { kind: DISPATCH_ACTION_KIND.CALENDAR_RECONCILE },
+        options
+      )
+    },
+    selection: {
+      ids: () => engine.getSelectedActivityIds(),
+      toggle: ({ checked, ...input }) => engine.dispatch({
+        ...input,
+        kind: DISPATCH_ACTION_KIND.SELECTION_TOGGLE,
+        isChecked: checked
+      }),
+      replace: (activityIds, context = {}) => engine.dispatch({
+        ...context,
+        kind: DISPATCH_ACTION_KIND.SELECTION_REPLACE,
+        activityIds
+      })
+    },
+    view: {
+      hiddenActivityIds: () => engine.getHiddenActivityIds(),
+      visibleActivityIds: () => engine.getVisibleActivityIds(),
+      visualOrderIds: () => engine.getVisualOrderIds(),
+      filter: () => engine.getActiveFilter(),
+      setFilter: (input) => engine.dispatch({ ...input, kind: DISPATCH_ACTION_KIND.FILTER_SET }),
+      order: () => engine.getActiveOrder(),
+      setOrder: (rules, context = {}) => engine.dispatch({
+        ...context,
+        kind: DISPATCH_ACTION_KIND.SORT_SET,
+        rules
+      }),
+      setVisibility: (activityIds, context = {}) => engine.dispatch({
+        ...context,
+        kind: DISPATCH_ACTION_KIND.VISIBILITY_SET,
+        visibleIds: activityIds
+      }),
+      setStatusCriteria: (criteria, options) => engine.dispatch(
+        { kind: DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET, criteria },
+        options
+      )
+    },
+    baselines: {
+      refresh: applyBaselinePoints2,
+      setVisibility: applyBaselinePoints2,
+      setPonderatorCriterion: (criterion, options) => engine.dispatch(
+        { kind: DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET, criterion },
+        options
+      ),
+      activeFor: (activity) => getActiveBaseline(activity)
+    },
+    impactRequests: {
+      sync: (input) => engine.dispatch({ ...input, kind: DISPATCH_ACTION_KIND.SIR_SYNC })
+    },
+    persistence: {
+      hasChanges: () => engine.hasUnsavedChanges(),
+      modifiedActivities: () => engine.getModifiedActivities(),
+      modifiedActivityFields: () => engine.getModifiedActivityFields(),
+      newActivities: () => engine.getNewActivities(),
+      deletedActivities: () => engine.getDeletedActivitiesSinceLastSave(),
+      modifiedLinks: () => engine.getModifiedLinks(),
+      newLinks: () => engine.getNewLinks(),
+      deletedLinks: () => engine.getDeletedLinksSinceLastSave(),
+      captureHistoryBoundary: () => engine.capturePersistenceHistoryBoundary(),
+      readSnapshot: () => ({
+        activities: engine.getAllActivitiesView(),
+        links: engine.getAllLinksView(),
+        historyBoundary: engine.capturePersistenceHistoryBoundary()
+      }),
+      acknowledge: (checkpoint) => engine.dispatch({
+        kind: DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE,
+        checkpoint
+      })
+    },
+    history: {
+      undo: (options) => engine.undo(options),
+      redo: (options) => engine.redo(options),
+      canUndo: () => engine.canUndo(),
+      canRedo: () => engine.canRedo(),
+      clear: () => engine.clearHistory(),
+      depth: () => engine.undoDepth()
+    },
+    projection: {
+      changeSetFrom: (source) => engine.createProjectionChangeSetFrom(source)
+    },
+    criticalPath: {
+      get ready() {
+        return engine.criticalPathReady;
+      },
+      recompute: () => engine.recomputeCriticalPath(),
+      isSettled: () => engine.isCriticalPathSettled(),
+      whenSettled: () => engine.whenCriticalPathSettled()
+    },
+    diagnostics: {
+      auditEffectiveGraph: () => engine.auditEffectiveGraph(),
+      revision: () => engine.getScheduleRevision(),
+      canonicalDigest: () => engine.getCanonicalDigest()
+    }
+  };
+}
+
 // src/shared/queue.ts
 var Queue = class {
   items = [];
@@ -249,23 +925,105 @@ function dispatchVisibilitySet(action, deps) {
   return { ok: true, changes };
 }
 
+// src/autoscheduler/constants.ts
+var ACTIVITY_TYPE = {
+  TASK: "task",
+  PROJECT: "project",
+  MILESTONE: "milestone"
+};
+var TIMING = {
+  YIELD_SLICE_MS: 8
+};
+
+// src/internal/filter/types.ts
+var FILTER_VALUE_KIND = {
+  STRING: "string",
+  NUMBER: "number",
+  DATE: "date",
+  ID_ARRAY: "id-array",
+  ENUM: "enum",
+  BOOLEAN: "boolean",
+  REFERENCE: "reference"
+};
+var FILTER_FIELD = {
+  NAME: "name",
+  DESCRIPTION: "description",
+  CUSTOM_ID: "customId",
+  CORRELATIVE_ID: "correlativeId",
+  UNIQUE_CORRELATIVE_ID: "uniqueCorrelativeId",
+  PROGRESS: "progress",
+  DURATION_DAYS: "durationDays",
+  CALENDAR_DURATION: "calendarDuration",
+  COST: "cost",
+  USED_COST: "usedCost",
+  REAL_COST: "realCost",
+  WORK_HOURS: "workHours",
+  REAL_WORK_HOURS: "realWorkHours",
+  PONDERATOR: "ponderator",
+  FREE_SLACK_DAYS: "freeSlackDays",
+  TOTAL_SLACK_DAYS: "totalSlackDays",
+  EXPECTED_PROGRESS_BASELINE: "expectedProgressBaseline",
+  BASELINE_DURATION_DAYS: "baselineDurationDays",
+  BASELINE_COST: "baselineCost",
+  BASELINE_WORK_HOURS: "baselineWorkHours",
+  EXPECTED_PROGRESS: "expectedProgress",
+  START_DATE: "startDate",
+  END_DATE: "endDate",
+  CONSTRAINT_DATE: "constraintDate",
+  BASELINE_START_DATE: "baselineStartDate",
+  BASELINE_END_DATE: "baselineEndDate",
+  EARLY_START: "earlyStart",
+  EARLY_FINISH: "earlyFinish",
+  LATE_START: "lateStart",
+  LATE_FINISH: "lateFinish",
+  RESPONSABLE_IDS: "responsableIds",
+  TAG_IDS: "tagIds",
+  STATUS: "status",
+  CONSTRAINT_TYPE: "constraintType",
+  CALENDAR_ID: "calendarId",
+  SUBCONTRACT_ID: "subcontractId",
+  IS_CRITICAL: "isCritical"
+};
+var FILTER_OPERATOR = {
+  INCLUDES: "includes",
+  NOT_INCLUDES: "notIncludes",
+  IS: "is",
+  IS_NOT: "isNot",
+  EQUALS: "equals",
+  NOT_EQUALS: "notEquals",
+  GREATER_THAN: "greaterThan",
+  LESS_THAN: "lessThan",
+  GREATER_OR_EQUAL: "greaterOrEqual",
+  LESS_OR_EQUAL: "lessOrEqual",
+  AFTER: "after",
+  BEFORE: "before",
+  BETWEEN: "between",
+  SOME_OF: "someOf",
+  NOT_SOME_OF: "notSomeOf"
+};
+var FILTER_LOGIC = {
+  AND: "and",
+  OR: "or"
+};
+
 // src/internal/filter/field-registry.ts
+var BASELINE_EXPECTED_PROGRESS_PRECISION = 2;
 var STATUS_ORDER = [
-  "Waiting",
-  "Done",
-  "Doing",
-  "Overdue",
-  "Advancement"
+  STATUS.WAITING,
+  STATUS.DONE,
+  STATUS.DOING,
+  STATUS.OVERDUE,
+  STATUS.ADVANCEMENT
 ];
 var CONSTRAINT_TYPE_ORDER = [
-  "mfo",
-  "mso",
-  "snlt",
-  "snet",
-  "alap",
-  "asap",
-  "fnet",
-  "fnlt"
+  CONSTRAINT_TYPE.MFO,
+  CONSTRAINT_TYPE.MSO,
+  CONSTRAINT_TYPE.SNLT,
+  CONSTRAINT_TYPE.SNET,
+  CONSTRAINT_TYPE.ALAP,
+  CONSTRAINT_TYPE.ASAP,
+  CONSTRAINT_TYPE.FNET,
+  CONSTRAINT_TYPE.FNLT
 ];
 var MILLISECONDS_PER_DAY = 1e3 * 60 * 60 * 24;
 function toDays(hours, hoursPerDay) {
@@ -287,131 +1045,161 @@ function calendarDaySpan(startDate, endDate) {
   return Math.floor((endDay - startDay) / MILLISECONDS_PER_DAY) + 1;
 }
 var FIELD_REGISTRY = {
-  name: { valueKind: "string", extract: (activity) => activity.name },
-  description: {
-    valueKind: "string",
+  [FILTER_FIELD.NAME]: {
+    valueKind: FILTER_VALUE_KIND.STRING,
+    extract: (activity) => activity.name
+  },
+  [FILTER_FIELD.DESCRIPTION]: {
+    valueKind: FILTER_VALUE_KIND.STRING,
     extract: (activity) => activity.description
   },
-  customId: { valueKind: "string", extract: (activity) => activity.customId },
-  correlativeId: {
-    valueKind: "number",
+  [FILTER_FIELD.CUSTOM_ID]: {
+    valueKind: FILTER_VALUE_KIND.STRING,
+    extract: (activity) => activity.customId
+  },
+  [FILTER_FIELD.CORRELATIVE_ID]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.correlativeId
   },
-  uniqueCorrelativeId: {
-    valueKind: "number",
+  [FILTER_FIELD.UNIQUE_CORRELATIVE_ID]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => {
       const value = Number(activity.uniqueCorrelativeId);
       return Number.isFinite(value) ? value : null;
     }
   },
-  progress: { valueKind: "number", extract: (activity) => activity.progress },
-  durationDays: {
-    valueKind: "number",
+  [FILTER_FIELD.PROGRESS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.progress
+  },
+  [FILTER_FIELD.DURATION_DAYS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity, context) => toDays(activity.durationHours, context.hoursPerDay)
   },
-  calendarDuration: {
-    valueKind: "number",
-    extract: (activity) => activity.type === "milestone" ? 0 : calendarDaySpan(activity.startDate, activity.endDate)
+  [FILTER_FIELD.CALENDAR_DURATION]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.type === ACTIVITY_TYPE.MILESTONE ? 0 : calendarDaySpan(activity.startDate, activity.endDate)
+  },
+  [FILTER_FIELD.COST]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.cost
+  },
+  [FILTER_FIELD.USED_COST]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.usedCost
   },
-  cost: { valueKind: "number", extract: (activity) => activity.cost },
-  usedCost: { valueKind: "number", extract: (activity) => activity.usedCost },
-  realCost: { valueKind: "number", extract: (activity) => activity.realCost },
-  workHours: { valueKind: "number", extract: (activity) => activity.workHours },
-  realWorkHours: {
-    valueKind: "number",
+  [FILTER_FIELD.REAL_COST]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.realCost
+  },
+  [FILTER_FIELD.WORK_HOURS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    extract: (activity) => activity.workHours
+  },
+  [FILTER_FIELD.REAL_WORK_HOURS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.realWorkHours
   },
-  ponderator: {
-    valueKind: "number",
+  [FILTER_FIELD.PONDERATOR]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.ponderator
   },
-  freeSlackDays: {
-    valueKind: "number",
+  [FILTER_FIELD.FREE_SLACK_DAYS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity, context) => toDays(activity.freeSlackHours, context.hoursPerDay)
   },
-  totalSlackDays: {
-    valueKind: "number",
+  [FILTER_FIELD.TOTAL_SLACK_DAYS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity, context) => toDays(
       activity.criticalPath?.totalSlackHours ?? null,
       context.hoursPerDay
     )
   },
-  expectedProgressBaseline: {
-    valueKind: "number",
-    equalityPrecision: 2,
+  [FILTER_FIELD.EXPECTED_PROGRESS_BASELINE]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
+    equalityPrecision: BASELINE_EXPECTED_PROGRESS_PRECISION,
     extract: (activity) => activity.expectedProgressBaseline
   },
-  expectedProgress: {
-    valueKind: "number",
+  [FILTER_FIELD.EXPECTED_PROGRESS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.expectedProgress
   },
-  baselineDurationDays: {
-    valueKind: "number",
+  [FILTER_FIELD.BASELINE_DURATION_DAYS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.baselineSnapshot?.durationDays ?? null
   },
-  baselineCost: {
-    valueKind: "number",
+  [FILTER_FIELD.BASELINE_COST]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.baselineSnapshot?.cost ?? null
   },
-  baselineWorkHours: {
-    valueKind: "number",
+  [FILTER_FIELD.BASELINE_WORK_HOURS]: {
+    valueKind: FILTER_VALUE_KIND.NUMBER,
     extract: (activity) => activity.baselineSnapshot?.workHours ?? null
   },
-  startDate: { valueKind: "date", extract: (activity) => activity.startDate },
-  endDate: { valueKind: "date", extract: (activity) => activity.endDate },
-  constraintDate: {
-    valueKind: "date",
+  [FILTER_FIELD.START_DATE]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
+    extract: (activity) => activity.startDate
+  },
+  [FILTER_FIELD.END_DATE]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
+    extract: (activity) => activity.endDate
+  },
+  [FILTER_FIELD.CONSTRAINT_DATE]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.constraintDate
   },
-  baselineStartDate: {
-    valueKind: "date",
+  [FILTER_FIELD.BASELINE_START_DATE]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.baselineSnapshot?.startDate ?? null
   },
-  baselineEndDate: {
-    valueKind: "date",
+  [FILTER_FIELD.BASELINE_END_DATE]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.baselineSnapshot?.endDate ?? null
   },
-  earlyStart: {
-    valueKind: "date",
+  [FILTER_FIELD.EARLY_START]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.criticalPath?.earlyStart ?? null
   },
-  earlyFinish: {
-    valueKind: "date",
+  [FILTER_FIELD.EARLY_FINISH]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.criticalPath?.earlyFinish ?? null
   },
-  lateStart: {
-    valueKind: "date",
+  [FILTER_FIELD.LATE_START]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.criticalPath?.lateStart ?? null
   },
-  lateFinish: {
-    valueKind: "date",
+  [FILTER_FIELD.LATE_FINISH]: {
+    valueKind: FILTER_VALUE_KIND.DATE,
     extract: (activity) => activity.criticalPath?.lateFinish ?? null
   },
-  responsableIds: {
-    valueKind: "id-array",
+  [FILTER_FIELD.RESPONSABLE_IDS]: {
+    valueKind: FILTER_VALUE_KIND.ID_ARRAY,
     extract: (activity) => activity.responsableIds
   },
-  tagIds: { valueKind: "id-array", extract: (activity) => activity.tagIds },
-  status: {
-    valueKind: "enum",
+  [FILTER_FIELD.TAG_IDS]: {
+    valueKind: FILTER_VALUE_KIND.ID_ARRAY,
+    extract: (activity) => activity.tagIds
+  },
+  [FILTER_FIELD.STATUS]: {
+    valueKind: FILTER_VALUE_KIND.ENUM,
     order: STATUS_ORDER,
     extract: (activity) => activity.status
   },
-  constraintType: {
-    valueKind: "enum",
+  [FILTER_FIELD.CONSTRAINT_TYPE]: {
+    valueKind: FILTER_VALUE_KIND.ENUM,
     order: CONSTRAINT_TYPE_ORDER,
     extract: (activity) => activity.constraintType
   },
-  calendarId: {
-    valueKind: "reference",
+  [FILTER_FIELD.CALENDAR_ID]: {
+    valueKind: FILTER_VALUE_KIND.REFERENCE,
     extract: (activity) => activity.calendarId === null ? null : String(activity.calendarId)
   },
-  subcontractId: {
-    valueKind: "reference",
+  [FILTER_FIELD.SUBCONTRACT_ID]: {
+    valueKind: FILTER_VALUE_KIND.REFERENCE,
     extract: (activity) => activity.subcontractId === null ? null : String(activity.subcontractId)
   },
-  isCritical: {
-    valueKind: "boolean",
+  [FILTER_FIELD.IS_CRITICAL]: {
+    valueKind: FILTER_VALUE_KIND.BOOLEAN,
     extract: (activity) => activity.isCritical
   }
 };
@@ -432,27 +1220,31 @@ function utcDayMs(date2) {
 }
 function matchString(value, target, operator) {
   const isAbsent = value === null;
-  if (operator === "includes") {
+  if (operator === FILTER_OPERATOR.INCLUDES) {
     return !isAbsent && String(value).toLowerCase().includes(target.toLowerCase());
   }
-  if (operator === "notIncludes") {
+  if (operator === FILTER_OPERATOR.NOT_INCLUDES) {
     return isAbsent || !String(value).toLowerCase().includes(target.toLowerCase());
   }
-  if (operator === "is") return !isAbsent && String(value) === target;
-  if (operator === "isNot") return isAbsent || String(value) !== target;
+  if (operator === FILTER_OPERATOR.IS) {
+    return !isAbsent && String(value) === target;
+  }
+  if (operator === FILTER_OPERATOR.IS_NOT) {
+    return isAbsent || String(value) !== target;
+  }
   return false;
 }
 function matchNumber(value, target, operator, equalityPrecision) {
   if (value === null || typeof value !== "number") {
-    return operator === "notEquals";
+    return operator === FILTER_OPERATOR.NOT_EQUALS;
   }
   const equalityValue = equalityPrecision === void 0 ? value : Number(value.toFixed(equalityPrecision));
-  if (operator === "equals") return equalityValue === target;
-  if (operator === "notEquals") return equalityValue !== target;
-  if (operator === "greaterThan") return value > target;
-  if (operator === "lessThan") return value < target;
-  if (operator === "greaterOrEqual") return value >= target;
-  if (operator === "lessOrEqual") return value <= target;
+  if (operator === FILTER_OPERATOR.EQUALS) return equalityValue === target;
+  if (operator === FILTER_OPERATOR.NOT_EQUALS) return equalityValue !== target;
+  if (operator === FILTER_OPERATOR.GREATER_THAN) return value > target;
+  if (operator === FILTER_OPERATOR.LESS_THAN) return value < target;
+  if (operator === FILTER_OPERATOR.GREATER_OR_EQUAL) return value >= target;
+  if (operator === FILTER_OPERATOR.LESS_OR_EQUAL) return value <= target;
   return false;
 }
 function matchNumberBetween(value, minimum, maximum) {
@@ -462,8 +1254,8 @@ function matchDate(value, target, operator) {
   if (!(value instanceof Date)) return false;
   const valueDay = utcDayMs(value);
   const targetDay = utcDayMs(target);
-  if (operator === "after") return valueDay > targetDay;
-  if (operator === "before") return valueDay < targetDay;
+  if (operator === FILTER_OPERATOR.AFTER) return valueDay > targetDay;
+  if (operator === FILTER_OPERATOR.BEFORE) return valueDay < targetDay;
   return false;
 }
 function matchDateBetween(value, minimum, maximum) {
@@ -474,14 +1266,14 @@ function matchDateBetween(value, minimum, maximum) {
 function matchIdArray(value, allowed, operator) {
   const ids = Array.isArray(value) ? value : [];
   const intersects = ids.some((id) => allowed.has(String(id)));
-  if (operator === "someOf") return intersects;
-  if (operator === "notSomeOf") return !intersects;
+  if (operator === FILTER_OPERATOR.SOME_OF) return intersects;
+  if (operator === FILTER_OPERATOR.NOT_SOME_OF) return !intersects;
   return false;
 }
 function matchEnum(value, allowed, operator) {
   const isMember = value !== null && allowed.has(String(value));
-  if (operator === "someOf") return isMember;
-  if (operator === "notSomeOf") return !isMember;
+  if (operator === FILTER_OPERATOR.SOME_OF) return isMember;
+  if (operator === FILTER_OPERATOR.NOT_SOME_OF) return !isMember;
   return false;
 }
 function toAllowedSet(value) {
@@ -493,15 +1285,15 @@ function matchCriterion(activity, criterion, context) {
   if (descriptor === null) return false;
   const value = descriptor.extract(activity, context);
   const { operator } = criterion;
-  if (operator === "between") {
-    if (descriptor.valueKind === "number") {
+  if (operator === FILTER_OPERATOR.BETWEEN) {
+    if (descriptor.valueKind === FILTER_VALUE_KIND.NUMBER) {
       return matchNumberBetween(
         value,
         Number(criterion.value),
         Number(criterion.valueTo)
       );
     }
-    if (descriptor.valueKind === "date") {
+    if (descriptor.valueKind === FILTER_VALUE_KIND.DATE) {
       return matchDateBetween(
         value,
         toTargetDate(criterion.value),
@@ -510,10 +1302,10 @@ function matchCriterion(activity, criterion, context) {
     }
     return false;
   }
-  if (descriptor.valueKind === "string") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.STRING) {
     return matchString(value, String(criterion.value), operator);
   }
-  if (descriptor.valueKind === "number") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.NUMBER) {
     return matchNumber(
       value,
       Number(criterion.value),
@@ -521,17 +1313,17 @@ function matchCriterion(activity, criterion, context) {
       descriptor.equalityPrecision
     );
   }
-  if (descriptor.valueKind === "date") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.DATE) {
     return matchDate(value, toTargetDate(criterion.value), operator);
   }
-  if (descriptor.valueKind === "id-array") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.ID_ARRAY) {
     return matchIdArray(value, toAllowedSet(criterion.value), operator);
   }
   return matchEnum(value, toAllowedSet(criterion.value), operator);
 }
 function matchesCriteria(activity, filter, context) {
   if (filter.criteria.length === 0) return true;
-  if (filter.logic === "or") {
+  if (filter.logic === FILTER_LOGIC.OR) {
     return filter.criteria.some(
       (criterion) => matchCriterion(activity, criterion, context)
     );
@@ -686,36 +1478,62 @@ function buildFilterContext(hoursPerDay) {
 }
 
 // src/internal/filter/validate.ts
+var FILTER_REJECTION_REASON = {
+  UNKNOWN_FIELD: "unknown_field",
+  UNKNOWN_OPERATOR: "unknown_operator",
+  INVALID_VALUE: "invalid_value"
+};
 var OPERATORS_BY_KIND = {
-  string: /* @__PURE__ */ new Set(["includes", "notIncludes", "is", "isNot"]),
-  number: /* @__PURE__ */ new Set([
-    "equals",
-    "notEquals",
-    "greaterThan",
-    "lessThan",
-    "greaterOrEqual",
-    "lessOrEqual",
-    "between"
+  [FILTER_VALUE_KIND.STRING]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.INCLUDES,
+    FILTER_OPERATOR.NOT_INCLUDES,
+    FILTER_OPERATOR.IS,
+    FILTER_OPERATOR.IS_NOT
   ]),
-  date: /* @__PURE__ */ new Set(["after", "before", "between"]),
-  "id-array": /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
-  enum: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
-  boolean: /* @__PURE__ */ new Set(["someOf", "notSomeOf"]),
-  reference: /* @__PURE__ */ new Set(["someOf", "notSomeOf"])
+  [FILTER_VALUE_KIND.NUMBER]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.EQUALS,
+    FILTER_OPERATOR.NOT_EQUALS,
+    FILTER_OPERATOR.GREATER_THAN,
+    FILTER_OPERATOR.LESS_THAN,
+    FILTER_OPERATOR.GREATER_OR_EQUAL,
+    FILTER_OPERATOR.LESS_OR_EQUAL,
+    FILTER_OPERATOR.BETWEEN
+  ]),
+  [FILTER_VALUE_KIND.DATE]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.AFTER,
+    FILTER_OPERATOR.BEFORE,
+    FILTER_OPERATOR.BETWEEN
+  ]),
+  [FILTER_VALUE_KIND.ID_ARRAY]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.SOME_OF,
+    FILTER_OPERATOR.NOT_SOME_OF
+  ]),
+  [FILTER_VALUE_KIND.ENUM]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.SOME_OF,
+    FILTER_OPERATOR.NOT_SOME_OF
+  ]),
+  [FILTER_VALUE_KIND.BOOLEAN]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.SOME_OF,
+    FILTER_OPERATOR.NOT_SOME_OF
+  ]),
+  [FILTER_VALUE_KIND.REFERENCE]: /* @__PURE__ */ new Set([
+    FILTER_OPERATOR.SOME_OF,
+    FILTER_OPERATOR.NOT_SOME_OF
+  ])
 };
 function normalizeDateRange(value) {
   if (value === void 0) return { ok: true, dateRange: void 0 };
   if (typeof value !== "object" || value === null) {
-    return { ok: false, reason: "invalid_value" };
+    return { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE };
   }
   const { start, end } = value;
   if (!(start instanceof Date) || !(end instanceof Date)) {
-    return { ok: false, reason: "invalid_value" };
+    return { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE };
   }
   const startTime = start.getTime();
   const endTime = end.getTime();
   if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime > endTime) {
-    return { ok: false, reason: "invalid_value" };
+    return { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE };
   }
   return {
     ok: true,
@@ -724,30 +1542,32 @@ function normalizeDateRange(value) {
 }
 function normalizeCriterion(criterion) {
   const descriptor = getFieldDescriptor(criterion.field);
-  if (descriptor === null) return { ok: false, reason: "unknown_field" };
+  if (descriptor === null) {
+    return { ok: false, reason: FILTER_REJECTION_REASON.UNKNOWN_FIELD };
+  }
   if (!OPERATORS_BY_KIND[descriptor.valueKind].has(criterion.operator)) {
-    return { ok: false, reason: "unknown_operator" };
+    return { ok: false, reason: FILTER_REJECTION_REASON.UNKNOWN_OPERATOR };
   }
-  if (criterion.operator === "between") {
+  if (criterion.operator === FILTER_OPERATOR.BETWEEN) {
     return normalizeBetweenCriterion(criterion, descriptor.valueKind);
   }
-  if (descriptor.valueKind === "number") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.NUMBER) {
     const value = normalizeNumberValue(criterion.value);
-    return value === null ? { ok: false, reason: "invalid_value" } : {
+    return value === null ? { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE } : {
       ok: true,
       criterion: { ...criterion, value }
     };
   }
-  if (descriptor.valueKind === "date") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.DATE) {
     const value = normalizeDateValue(criterion.value);
-    return value === null ? { ok: false, reason: "invalid_value" } : {
+    return value === null ? { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE } : {
       ok: true,
       criterion: { ...criterion, value }
     };
   }
   const rejection = validateValueForKind(criterion, descriptor.valueKind);
   if (rejection !== null) return { ok: false, reason: rejection };
-  if (descriptor.valueKind === "boolean") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.BOOLEAN) {
     return {
       ok: true,
       criterion: {
@@ -756,7 +1576,7 @@ function normalizeCriterion(criterion) {
       }
     };
   }
-  if (descriptor.valueKind === "id-array" || descriptor.valueKind === "enum" || descriptor.valueKind === "reference") {
+  if (descriptor.valueKind === FILTER_VALUE_KIND.ID_ARRAY || descriptor.valueKind === FILTER_VALUE_KIND.ENUM || descriptor.valueKind === FILTER_VALUE_KIND.REFERENCE) {
     return {
       ok: true,
       criterion: {
@@ -772,41 +1592,41 @@ function normalizeCriterion(criterion) {
   return { ok: true, criterion };
 }
 function normalizeBetweenCriterion(criterion, valueKind) {
-  if (valueKind === "number") {
+  if (valueKind === FILTER_VALUE_KIND.NUMBER) {
     const value = normalizeNumberValue(criterion.value);
     const valueTo = normalizeNumberValue(criterion.valueTo);
     if (value === null || valueTo === null || value > valueTo) {
-      return { ok: false, reason: "invalid_value" };
+      return { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE };
     }
     return {
       ok: true,
       criterion: { ...criterion, value, valueTo }
     };
   }
-  if (valueKind === "date") {
+  if (valueKind === FILTER_VALUE_KIND.DATE) {
     const value = normalizeDateValue(criterion.value);
     const valueTo = normalizeDateValue(criterion.valueTo);
     if (value === null || valueTo === null || value.getTime() > valueTo.getTime()) {
-      return { ok: false, reason: "invalid_value" };
+      return { ok: false, reason: FILTER_REJECTION_REASON.INVALID_VALUE };
     }
     return {
       ok: true,
       criterion: { ...criterion, value, valueTo }
     };
   }
-  return { ok: false, reason: "unknown_operator" };
+  return { ok: false, reason: FILTER_REJECTION_REASON.UNKNOWN_OPERATOR };
 }
 function validateValueForKind(criterion, valueKind) {
   const { value } = criterion;
-  if (valueKind === "boolean") {
-    return Array.isArray(value) && value.every((item) => typeof item === "boolean") ? null : "invalid_value";
+  if (valueKind === FILTER_VALUE_KIND.BOOLEAN) {
+    return Array.isArray(value) && value.every((item) => typeof item === "boolean") ? null : FILTER_REJECTION_REASON.INVALID_VALUE;
   }
-  if (valueKind === "id-array" || valueKind === "enum" || valueKind === "reference") {
+  if (valueKind === FILTER_VALUE_KIND.ID_ARRAY || valueKind === FILTER_VALUE_KIND.ENUM || valueKind === FILTER_VALUE_KIND.REFERENCE) {
     return Array.isArray(value) && value.every(
       (item) => typeof item === "string" || typeof item === "number"
-    ) ? null : "invalid_value";
+    ) ? null : FILTER_REJECTION_REASON.INVALID_VALUE;
   }
-  if (Array.isArray(value)) return "invalid_value";
+  if (Array.isArray(value)) return FILTER_REJECTION_REASON.INVALID_VALUE;
   return null;
 }
 function normalizeNumberValue(value) {
@@ -854,455 +1674,198 @@ function resolveFilter(adapter, filter, hoursPerDay) {
   });
   return { visibleIds: projection.visibleIds, projection };
 }
-function dispatchFilterSet(action, deps) {
-  const { adapter, hoursPerDay } = deps;
-  const criteria = [];
-  for (const criterion of action.criteria) {
-    const result = normalizeCriterion(criterion);
-    if (!result.ok) return { ok: false, reason: result.reason };
-    criteria.push(result.criterion);
-  }
-  const rangeResult = normalizeDateRange(action.dateRange);
-  if (!rangeResult.ok) return { ok: false, reason: rangeResult.reason };
-  const filter = cloneDomainValue(
-    rangeResult.dateRange === void 0 ? { criteria, logic: action.logic } : {
-      criteria,
-      logic: action.logic,
-      dateRange: rangeResult.dateRange
-    }
-  );
-  adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
-  const { visibleIds, projection } = resolveFilter(
-    adapter,
-    filter,
-    hoursPerDay
-  );
-  adapter.setFilterProjection(projection);
-  const viewState = applyVisibleSet(adapter, visibleIds);
-  const changes = {
-    source: action,
-    activities: [],
-    links: [],
-    calendars: [],
-    trackingEvents: [],
-    viewState
-  };
-  return { ok: true, changes };
-}
-
-// src/internal/hierarchy/root-parent.ts
-var ROOT_PARENT_ID = "0";
-var ROOT_PROJECT_CORRELATIVE_ID = 0;
-function isRootParent(parent) {
-  return parent == null || parent === 0 || parent === ROOT_PARENT_ID;
-}
-function normalizeParentKey(parent) {
-  return isRootParent(parent) ? ROOT_PARENT_ID : String(parent);
-}
-
-// src/internal/hierarchy/visual-order.ts
-var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
-function getChildrenInVisualOrder(parentId, adapter) {
-  const children = collectChildrenSnapshots(parentId, adapter);
-  const userOrder = adapter.getOrderComparator?.() ?? null;
-  children.sort(
-    userOrder === null ? compareActivitiesInVisualOrder : (a, b) => userOrder(a, b) || compareActivitiesInVisualOrder(a, b)
-  );
-  return children.map((activity) => String(activity.id));
-}
-function iterateInVisualOrder(adapter) {
-  const result = [];
-  const visit = (activity) => {
-    result.push(activity);
-    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
-    for (const childId of childIds) {
-      const child = adapter.getActivity(childId);
-      if (child) visit(child);
-    }
-  };
-  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
-  for (const rootId of rootIds) {
-    const root = adapter.getActivity(rootId);
-    if (root) visit(root);
-  }
-  return result;
-}
-function findPreviousNonSelectedSibling(taskId, selected, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return null;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  const idx = siblings.findIndex((id) => String(id) === String(taskId));
-  if (idx <= 0) return null;
-  for (let i = idx - 1; i >= 0; i--) {
-    const candidateId = siblings[i];
-    if (candidateId === void 0) continue;
-    if (!setHas(selected, candidateId)) return candidateId;
-  }
-  return null;
-}
-function visualIndexInParent(taskId, adapter) {
-  const activity = adapter.getActivity(taskId);
-  if (!activity) return -1;
-  const parentKey = parentKeyOf(activity);
-  const siblings = getChildrenInVisualOrder(parentKey, adapter);
-  return siblings.findIndex((id) => String(id) === String(taskId));
-}
-function collectChildrenSnapshots(parentId, adapter) {
-  const childIds = String(parentId) === ROOT_PARENT_ID ? adapter.getRootIds?.() ?? adapter.getChildren(ROOT_PARENT_ID) : adapter.getChildren(parentId);
-  const out = [];
-  for (const id of childIds) {
-    const snap = adapter.getActivity(id);
-    if (snap) out.push(snap);
-  }
-  return out;
-}
-function compareActivitiesInVisualOrder(a, b) {
-  const ac = correlativeIdOf(a);
-  const bc = correlativeIdOf(b);
-  if (ac !== bc) return ac - bc;
-  return String(a.id).localeCompare(String(b.id));
-}
-function correlativeIdOf(activity) {
-  const raw = activity.correlativeId;
-  const n = typeof raw === "number" ? raw : Number(raw);
-  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
-}
-function parentKeyOf(activity) {
-  const parentId = activity.parentId;
-  if (parentId === null) return "0";
-  return parentId;
-}
-function setHas(set, id) {
-  if (set.has(id)) return true;
-  return set.has(String(id));
-}
-
-// src/dispatch/shared/collect-branch-order.ts
-function collectBranchOrder(adapter) {
-  const branches = [];
-  const visit = (parentId) => {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
-    if (childIds.length > 1) {
-      branches.push({ parentId, childIds });
-    }
-    for (const childId of childIds) {
-      visit(childId);
-    }
-  };
-  visit(ROOT_PARENT_ID);
-  return branches;
-}
-function collectBranchOrderForParents(adapter, parentIds) {
-  const branches = [];
-  for (const parentId of parentIds) {
-    const childIds = getChildrenInVisualOrder(parentId, adapter);
-    if (childIds.length > 1) branches.push({ parentId, childIds });
-  }
-  return branches;
-}
-
-// src/dispatch/order.ts
-function validateRule(rule) {
-  if (getFieldDescriptor(rule.field) === null) return "unknown_field";
-  if (rule.direction !== "asc" && rule.direction !== "desc") {
-    return "unknown_operator";
-  }
-  return null;
-}
-function dispatchSortSet(action, deps) {
-  const { adapter } = deps;
-  for (const rule of action.rules) {
-    const rejection = validateRule(rule);
-    if (rejection !== null) return { ok: false, reason: rejection };
-  }
-  const order = action.rules.length === 0 ? null : cloneDomainValue({ rules: action.rules });
-  adapter.setActiveOrder(order);
-  const changes = {
-    source: action,
-    activities: [],
-    links: [],
-    calendars: [],
-    trackingEvents: [],
-    order: collectBranchOrder(adapter)
-  };
-  return { ok: true, changes };
-}
-
-// src/constants/columns.ts
-var EDITABLE = {
-  TEXT: "text",
-  DESCRIPTION: "description",
-  DURATION: "duration",
-  PROGRESS: "progress",
-  COST: "cost",
-  USED_COST: "used_cost",
-  HH_WORK_TIME: "hhWorkTime",
-  START_DATE: "start_date",
-  END_DATE: "end_date",
-  CONSTRAINT_TYPE: "constraint_type",
-  CONSTRAINT_DATE: "constraint_date",
-  CALENDAR_ID: "calendar_id",
-  CUSTOM_ID: "custom_id",
-  SUBCONTRACT_ID: "subcontractId",
-  RESPONSABLES: "responsables",
-  TAGS: "tags",
-  CUSTOM_PREDECESSORS: "custom_predecessors",
-  CUSTOM_SUCESSORS: "custom_sucessors"
-};
-var READ_ONLY = {
-  REAL_WORK: "real_work",
-  REAL_COST: "real_cost",
-  EXPECTED_PROGRESS: "expected_progress",
-  EXPECTED_PROGRESS_BASE: "expected_progress_base",
-  START_BASE: "start_base",
-  END_BASE: "end_base",
-  DURATION_BASE: "duration_base",
-  COST_BASE: "cost_base",
-  WORK_BASE: "work_base",
-  CALENDAR_DURATION: "calendarDuration",
-  IS_CRITICAL: "is_critical",
-  EARLY_START: "earlyStart",
-  EARLY_FINISH: "earlyFinish",
-  LATE_START: "lateStart",
-  LATE_FINISH: "lateFinish",
-  FREE_SLACK: "freeSlack",
-  TOTAL_SLACK: "totalSlack",
-  CORRELATIVE_ID: "correlative_id",
-  UNIQUE_CORRELATIVE_ID: "unique_correlative_id",
-  PONDERATOR: "ponderator",
-  STATUS: "status"
-};
-var COLUMN = { ...EDITABLE, ...READ_ONLY };
-
-// src/shared/assert-never.ts
-function assertNever(value, message) {
-  throw new Error(message);
-}
-
-// src/autoscheduler/utils/cancellation.ts
-function createIsCurrent(id, getCurrentId) {
-  return () => getCurrentId() === id;
+function dispatchFilterSet(action, deps) {
+  const { adapter, hoursPerDay } = deps;
+  const criteria = [];
+  for (const criterion of action.criteria) {
+    const result = normalizeCriterion(criterion);
+    if (!result.ok) return { ok: false, reason: result.reason };
+    criteria.push(result.criterion);
+  }
+  const rangeResult = normalizeDateRange(action.dateRange);
+  if (!rangeResult.ok) return { ok: false, reason: rangeResult.reason };
+  const filter = cloneDomainValue(
+    rangeResult.dateRange === void 0 ? { criteria, logic: action.logic } : {
+      criteria,
+      logic: action.logic,
+      dateRange: rangeResult.dateRange
+    }
+  );
+  adapter.setActiveFilter(isEmptyFilter(filter) ? null : filter);
+  const { visibleIds, projection } = resolveFilter(
+    adapter,
+    filter,
+    hoursPerDay
+  );
+  adapter.setFilterProjection(projection);
+  const viewState = applyVisibleSet(adapter, visibleIds);
+  const changes = {
+    source: action,
+    activities: [],
+    links: [],
+    calendars: [],
+    trackingEvents: [],
+    viewState
+  };
+  return { ok: true, changes };
 }
 
-// src/types.ts
-var WORK_TIME_DIRECTION = {
-  FUTURE: "future",
-  PAST: "past"
-};
-var CALENDAR_UNIT = {
-  HOUR: "hour",
-  DAY: "day"
-};
-var STATUS = {
-  DONE: "Done",
-  OVERDUE: "Overdue",
-  ADVANCEMENT: "Advancement",
-  WAITING: "Waiting",
-  DOING: "Doing"
+// src/internal/order/types.ts
+var ORDER_DIRECTION = {
+  ASCENDING: "asc",
+  DESCENDING: "desc"
 };
 
-// src/constraints/index.ts
-var CONSTRAINT_TYPE = {
-  ASAP: "asap",
-  ALAP: "alap",
-  SNET: "snet",
-  SNLT: "snlt",
-  FNET: "fnet",
-  FNLT: "fnlt",
-  MSO: "mso",
-  MFO: "mfo"
-};
-var VIOLATION_RULES = {
-  mso: () => true,
-  mfo: () => true,
-  snlt: (constraint, projected) => constraint < projected,
-  snet: (constraint, projected) => constraint > projected,
-  fnlt: (constraint, projected) => constraint < projected,
-  fnet: (constraint, projected) => constraint > projected
-};
-function checkConstraintViolation(constraintType, constraintDate, projectedDate) {
-  if (!constraintDate) return { violated: false };
-  const rule = VIOLATION_RULES[constraintType];
-  if (!rule) return { violated: false };
-  if (rule(constraintDate, projectedDate)) {
-    return { violated: true, constraintType, constraintDate };
-  }
-  return { violated: false };
+// src/internal/hierarchy/root-parent.ts
+var ROOT_PARENT_ID = "0";
+var ROOT_PROJECT_CORRELATIVE_ID = 0;
+function isRootParent(parent) {
+  return parent == null || parent === 0 || parent === ROOT_PARENT_ID;
 }
-var START_BASED_CONSTRAINTS = /* @__PURE__ */ new Set([
-  "mso",
-  "snet",
-  "snlt"
-]);
-function pickProjectedDateForConstraint(constraintType, projectedStart, projectedEnd) {
-  return START_BASED_CONSTRAINTS.has(constraintType) ? projectedStart : projectedEnd;
+function normalizeParentKey(parent) {
+  return isRootParent(parent) ? ROOT_PARENT_ID : String(parent);
 }
-function buildConstraintNotification(constraintType, constraintDate, projectedDate) {
-  return {
-    type: "constraint",
-    messageKey: "constraint_violation",
-    data: {
-      constraintType,
-      constraintDate,
-      ...projectedDate ? { projectedDate } : {}
+
+// src/internal/hierarchy/visual-order.ts
+var NOT_SET_SORT_VALUE = Number.MAX_SAFE_INTEGER;
+function getChildrenInVisualOrder(parentId, adapter) {
+  const children = collectChildrenSnapshots(parentId, adapter);
+  const userOrder = adapter.getOrderComparator?.() ?? null;
+  children.sort(
+    userOrder === null ? compareActivitiesInVisualOrder : (a, b) => userOrder(a, b) || compareActivitiesInVisualOrder(a, b)
+  );
+  return children.map((activity) => String(activity.id));
+}
+function iterateInVisualOrder(adapter) {
+  const result = [];
+  const visit = (activity) => {
+    result.push(activity);
+    const childIds = getChildrenInVisualOrder(String(activity.id), adapter);
+    for (const childId of childIds) {
+      const child = adapter.getActivity(childId);
+      if (child) visit(child);
     }
   };
-}
-var CONSTRAINT_CASES = {
-  snet: { startOfDay: true, direction: WORK_TIME_DIRECTION.FUTURE },
-  snlt: { startOfDay: true, direction: WORK_TIME_DIRECTION.PAST },
-  fnet: { startOfDay: false, direction: WORK_TIME_DIRECTION.FUTURE },
-  fnlt: { startOfDay: false, direction: WORK_TIME_DIRECTION.PAST },
-  mso: { startOfDay: true, direction: WORK_TIME_DIRECTION.FUTURE },
-  mfo: { startOfDay: false, direction: WORK_TIME_DIRECTION.PAST }
-};
-var startOfUtcDay = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
-var addUtcDays = (d, n) => new Date(d.getTime() + n * 864e5);
-var sameUtcDay = (a, b) => a.getUTCFullYear() === b.getUTCFullYear() && a.getUTCMonth() === b.getUTCMonth() && a.getUTCDate() === b.getUTCDate();
-function getEffectiveConstraintDate(activity, adapter) {
-  if (!activity.constraintDate || !activity.constraintType) return null;
-  const config = CONSTRAINT_CASES[activity.constraintType];
-  if (!config) return activity.constraintDate;
-  const cd = activity.constraintDate;
-  const firstWorkOfDay = adapter.getClosestWorkTime({
-    date: startOfUtcDay(cd),
-    dir: WORK_TIME_DIRECTION.FUTURE,
-    task: activity
-  });
-  if (sameUtcDay(firstWorkOfDay, cd)) {
-    if (cd.getTime() !== startOfUtcDay(cd).getTime()) return cd;
-    if (config.startOfDay) return firstWorkOfDay;
-    return adapter.getClosestWorkTime({
-      date: addUtcDays(startOfUtcDay(cd), 1),
-      dir: WORK_TIME_DIRECTION.PAST,
-      task: activity
-    });
+  const rootIds = getChildrenInVisualOrder(ROOT_PARENT_ID, adapter);
+  for (const rootId of rootIds) {
+    const root = adapter.getActivity(rootId);
+    if (root) visit(root);
   }
-  const effectiveMidnight = startOfUtcDay(
-    adapter.getClosestWorkTime({
-      date: cd,
-      dir: config.direction,
-      task: activity
-    })
-  );
-  if (config.startOfDay) {
-    return adapter.getClosestWorkTime({
-      date: effectiveMidnight,
-      dir: WORK_TIME_DIRECTION.FUTURE,
-      task: activity
-    });
+  return result;
+}
+function findPreviousNonSelectedSibling(taskId, selected, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return null;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  const idx = siblings.findIndex((id) => String(id) === String(taskId));
+  if (idx <= 0) return null;
+  for (let i = idx - 1; i >= 0; i--) {
+    const candidateId = siblings[i];
+    if (candidateId === void 0) continue;
+    if (!setHas(selected, candidateId)) return candidateId;
   }
-  return adapter.getClosestWorkTime({
-    date: addUtcDays(effectiveMidnight, 1),
-    dir: WORK_TIME_DIRECTION.PAST,
-    task: activity
-  });
+  return null;
 }
-function computeConstraintBounds(activity, adapter) {
-  const empty = {
-    earliestStart: null,
-    latestStart: null,
-    earliestEnd: null,
-    latestEnd: null
-  };
-  const type = activity.constraintType;
-  if (!type || type === "asap" || type === "alap") return empty;
-  const constraintDate = getEffectiveConstraintDate(activity, adapter);
-  if (!constraintDate) return empty;
-  const endFromStart = (start) => adapter.calculateEndDate({
-    startDate: start,
-    durationHours: activity.durationHours,
-    task: activity
-  });
-  const startFromEnd = (end) => adapter.calculateEndDate({
-    startDate: end,
-    durationHours: -activity.durationHours,
-    task: activity
-  });
-  switch (type) {
-    case "snet":
-      return {
-        earliestStart: constraintDate,
-        latestStart: null,
-        earliestEnd: endFromStart(constraintDate),
-        latestEnd: null
-      };
-    case "snlt":
-      return {
-        earliestStart: null,
-        latestStart: constraintDate,
-        earliestEnd: null,
-        latestEnd: endFromStart(constraintDate)
-      };
-    case "fnet":
-      return {
-        earliestStart: startFromEnd(constraintDate),
-        latestStart: null,
-        earliestEnd: constraintDate,
-        latestEnd: null
-      };
-    case "fnlt":
-      return {
-        earliestStart: null,
-        latestStart: startFromEnd(constraintDate),
-        earliestEnd: null,
-        latestEnd: constraintDate
-      };
-    case "mso": {
-      const end = endFromStart(constraintDate);
-      return {
-        earliestStart: constraintDate,
-        latestStart: constraintDate,
-        earliestEnd: end,
-        latestEnd: end
-      };
+function visualIndexInParent(taskId, adapter) {
+  const activity = adapter.getActivity(taskId);
+  if (!activity) return -1;
+  const parentKey = parentKeyOf(activity);
+  const siblings = getChildrenInVisualOrder(parentKey, adapter);
+  return siblings.findIndex((id) => String(id) === String(taskId));
+}
+function collectChildrenSnapshots(parentId, adapter) {
+  const childIds = String(parentId) === ROOT_PARENT_ID ? adapter.getRootIds?.() ?? adapter.getChildren(ROOT_PARENT_ID) : adapter.getChildren(parentId);
+  const out = [];
+  for (const id of childIds) {
+    const snap = adapter.getActivity(id);
+    if (snap) out.push(snap);
+  }
+  return out;
+}
+function compareActivitiesInVisualOrder(a, b) {
+  const ac = correlativeIdOf(a);
+  const bc = correlativeIdOf(b);
+  if (ac !== bc) return ac - bc;
+  return String(a.id).localeCompare(String(b.id));
+}
+function correlativeIdOf(activity) {
+  const raw = activity.correlativeId;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  return Number.isFinite(n) ? n : NOT_SET_SORT_VALUE;
+}
+function parentKeyOf(activity) {
+  const parentId = activity.parentId;
+  if (parentId === null) return "0";
+  return parentId;
+}
+function setHas(set, id) {
+  if (set.has(id)) return true;
+  return set.has(String(id));
+}
+
+// src/dispatch/shared/collect-branch-order.ts
+function collectBranchOrder(adapter) {
+  const branches = [];
+  const visit = (parentId) => {
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    if (childIds.length > 1) {
+      branches.push({ parentId, childIds });
     }
-    case "mfo": {
-      const start = startFromEnd(constraintDate);
-      return {
-        earliestStart: start,
-        latestStart: start,
-        earliestEnd: constraintDate,
-        latestEnd: constraintDate
-      };
+    for (const childId of childIds) {
+      visit(childId);
     }
-    default:
-      return empty;
-  }
+  };
+  visit(ROOT_PARENT_ID);
+  return branches;
 }
-function isStartWithinBounds(start, bounds) {
-  if (bounds.earliestStart && start < bounds.earliestStart) return false;
-  if (bounds.latestStart && start > bounds.latestStart) return false;
-  return true;
+function collectBranchOrderForParents(adapter, parentIds) {
+  const branches = [];
+  for (const parentId of parentIds) {
+    const childIds = getChildrenInVisualOrder(parentId, adapter);
+    if (childIds.length > 1) branches.push({ parentId, childIds });
+  }
+  return branches;
 }
-function clampStartToBounds(candidate, bounds) {
-  if (bounds.latestStart && candidate > bounds.latestStart) {
-    return bounds.latestStart;
+
+// src/dispatch/order.ts
+function validateRule(rule) {
+  if (getFieldDescriptor(rule.field) === null) {
+    return FILTER_REJECTION_REASON.UNKNOWN_FIELD;
   }
-  if (bounds.earliestStart && candidate < bounds.earliestStart) {
-    return bounds.earliestStart;
+  if (rule.direction !== ORDER_DIRECTION.ASCENDING && rule.direction !== ORDER_DIRECTION.DESCENDING) {
+    return FILTER_REJECTION_REASON.UNKNOWN_OPERATOR;
   }
-  return candidate;
+  return null;
+}
+function dispatchSortSet(action, deps) {
+  const { adapter } = deps;
+  for (const rule of action.rules) {
+    const rejection = validateRule(rule);
+    if (rejection !== null) return { ok: false, reason: rejection };
+  }
+  const order = action.rules.length === 0 ? null : cloneDomainValue({ rules: action.rules });
+  adapter.setActiveOrder(order);
+  const changes = {
+    source: action,
+    activities: [],
+    links: [],
+    calendars: [],
+    trackingEvents: [],
+    order: collectBranchOrder(adapter)
+  };
+  return { ok: true, changes };
 }
 
-// src/autoscheduler/types.ts
-var LINK_TYPE = {
-  FINISH_TO_START: "0",
-  START_TO_START: "1",
-  FINISH_TO_FINISH: "2",
-  START_TO_FINISH: "3"
-};
+// src/shared/assert-never.ts
+function assertNever(value, message) {
+  throw new Error(message);
+}
 
-// src/autoscheduler/constants.ts
-var ACTIVITY_TYPE = {
-  TASK: "task",
-  PROJECT: "project",
-  MILESTONE: "milestone"
-};
-var TIMING = {
-  YIELD_SLICE_MS: 8
-};
+// src/autoscheduler/utils/cancellation.ts
+function createIsCurrent(id, getCurrentId) {
+  return () => getCurrentId() === id;
+}
 
 // src/shared/timing.ts
 var isNode = typeof window === "undefined";
@@ -1817,9 +2380,10 @@ function findConnectedGroupForTrigger(triggerId, links) {
 }
 
 // src/constants/progress.ts
+var NOT_STARTED_PROGRESS = 0;
 var COMPLETED_PROGRESS = 100;
 function isAutoSchedulingEnabledForProgress(progress) {
-  return progress === 0;
+  return progress === NOT_STARTED_PROGRESS;
 }
 
 // src/autoscheduler/engine/link-calculator.ts
@@ -2761,11 +3325,11 @@ function corruptActivityIds(edges) {
 // src/autoscheduler/links/apply-link-operation.ts
 function applyLinkOperation(op, deps) {
   switch (op.kind) {
-    case "create":
+    case LINK_OPERATION_KIND.CREATE:
       return applyCreate(op, deps);
-    case "update":
+    case LINK_OPERATION_KIND.UPDATE:
       return applyLinkUpdate(op, deps.port);
-    case "delete":
+    case LINK_OPERATION_KIND.DELETE:
       return applyDelete(op, deps);
   }
 }
@@ -2783,15 +3347,24 @@ function applyLinkCreates(links, deps) {
   let rejected = null;
   for (const { operation, linkId } of links) {
     if (String(operation.source) === String(operation.target)) {
-      rejected = { applied: false, rejected: "self-link" };
+      rejected = {
+        applied: false,
+        rejected: LINK_REJECTION_REASON.SELF_LINK
+      };
       break;
     }
     if (!deps.port.getActivity(operation.source) || !deps.port.getActivity(operation.target)) {
-      rejected = { applied: false, rejected: "activity-missing" };
+      rejected = {
+        applied: false,
+        rejected: LINK_REJECTION_REASON.ACTIVITY_MISSING
+      };
       break;
     }
     if (isSummaryHierarchyLink(operation.source, operation.target, deps.port)) {
-      rejected = { applied: false, rejected: "hierarchy-link" };
+      rejected = {
+        applied: false,
+        rejected: LINK_REJECTION_REASON.HIERARCHY_LINK
+      };
       break;
     }
     const key = linkKey(operation);
@@ -2799,7 +3372,7 @@ function applyLinkCreates(links, deps) {
     if (duplicateId !== void 0) {
       rejected = {
         applied: false,
-        rejected: "duplicate",
+        rejected: LINK_REJECTION_REASON.DUPLICATE,
         linkId: duplicateId
       };
       break;
@@ -2809,12 +3382,12 @@ function applyLinkCreates(links, deps) {
       source: operation.source,
       target: operation.target
     })) {
-      return { applied: false, rejected: "cycle" };
+      return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
     }
     edges.push({ source: operation.source, target: operation.target });
   }
   if (!existingGraphHasCycle && hasDirectedCycle(edges)) {
-    return { applied: false, rejected: "cycle" };
+    return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
   }
   if (rejected) return rejected;
   const proposedLinks = [
@@ -2835,7 +3408,7 @@ function applyLinkCreates(links, deps) {
     proposedLinks
   });
   if (!effectiveVerdict.ok) {
-    return { applied: false, rejected: "cycle" };
+    return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
   }
   for (const { operation, linkId } of links) {
     const preserved = deps.preserved?.get(linkId);
@@ -2860,20 +3433,30 @@ function linkKey(link) {
 function applyCreate(op, deps) {
   const { port } = deps;
   if (String(op.source) === String(op.target)) {
-    return { applied: false, rejected: "self-link" };
+    return { applied: false, rejected: LINK_REJECTION_REASON.SELF_LINK };
   }
   const src = port.getActivity(op.source);
   const tgt = port.getActivity(op.target);
   if (!src || !tgt) {
-    return { applied: false, rejected: "activity-missing" };
+    return {
+      applied: false,
+      rejected: LINK_REJECTION_REASON.ACTIVITY_MISSING
+    };
   }
   if (isSummaryHierarchyLink(op.source, op.target, port)) {
-    return { applied: false, rejected: "hierarchy-link" };
+    return {
+      applied: false,
+      rejected: LINK_REJECTION_REASON.HIERARCHY_LINK
+    };
   }
   const existingLinks = port.getAllLinks();
   for (const l of existingLinks) {
     if (String(l.source) === String(op.source) && String(l.target) === String(op.target) && l.type === op.type) {
-      return { applied: false, rejected: "duplicate", linkId: l.id };
+      return {
+        applied: false,
+        rejected: LINK_REJECTION_REASON.DUPLICATE,
+        linkId: l.id
+      };
     }
   }
   const asEdges = existingLinks.map((l) => ({
@@ -2881,7 +3464,7 @@ function applyCreate(op, deps) {
     target: l.target
   }));
   if (wouldIntroduceCycle(asEdges, { source: op.source, target: op.target })) {
-    return { applied: false, rejected: "cycle" };
+    return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
   }
   const id = (deps.newLinkId ?? defaultNewLinkId)();
   const link = {
@@ -2899,14 +3482,16 @@ function applyCreate(op, deps) {
     proposedLinks: [...existingLinks, link]
   });
   if (!effectiveVerdict.ok) {
-    return { applied: false, rejected: "cycle" };
+    return { applied: false, rejected: LINK_REJECTION_REASON.CYCLE };
   }
   port.addLink(link);
   return { applied: true, linkId: id };
 }
 function applyLinkUpdate(op, port) {
   const link = port.getLink(op.linkId);
-  if (!link) return { applied: false, rejected: "link-missing" };
+  if (!link) {
+    return { applied: false, rejected: LINK_REJECTION_REASON.LINK_MISSING };
+  }
   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 };
@@ -2914,7 +3499,9 @@ function applyLinkUpdate(op, port) {
 function applyDelete(op, deps) {
   const { port } = deps;
   const link = port.getLink(op.linkId);
-  if (!link) return { applied: false, rejected: "link-missing" };
+  if (!link) {
+    return { applied: false, rejected: LINK_REJECTION_REASON.LINK_MISSING };
+  }
   port.removeLink(op.linkId);
   return { applied: true, linkId: op.linkId };
 }
@@ -3106,8 +3693,8 @@ var currentImpl = {
 };
 
 // src/autoscheduler/date-math/types.ts
-function pickDatesForLinkType(source, target, linkType) {
-  switch (linkType) {
+function pickDatesForLinkType(source, target, linkType2) {
+  switch (linkType2) {
     case "0":
       return { sourceDate: source.endDate, targetDate: target.startDate };
     case "1":
@@ -4850,13 +5437,34 @@ function findPipelineForColumn(columnName) {
   return COLUMN_PIPELINES.get(columnName);
 }
 
+// src/dispatch/types.ts
+var ACTIVITY_BATCH_MODE = {
+  APPEND: "append",
+  REPLACE: "replace"
+};
+var SCHEDULE_EFFECT_KIND = {
+  SIR_AUTO_REJECT: "sir-auto-reject"
+};
+var SIR_AUTO_REJECT_REASON = {
+  DATE_CHANGED: "date_changed",
+  ACTIVITY_DELETED: "activity_deleted"
+};
+var CONSTRAINT_WARNING_KIND = {
+  VIOLATION: "constraint_violation"
+};
+var CHANGE_SET_SOURCE_KIND = {
+  INIT: "init",
+  UNDO: "undo",
+  REDO: "redo"
+};
+
 // src/dispatch/shared/constraint-warnings.ts
 function toConstraintWarning(activityId, notification) {
   if (!notification || notification.type !== "constraint") return null;
   const data = notification.data;
   if (!data?.constraintType || !data.constraintDate) return null;
   return {
-    kind: "constraint_violation",
+    kind: CONSTRAINT_WARNING_KIND.VIOLATION,
     activityId,
     constraintType: data.constraintType,
     constraintDate: data.constraintDate,
@@ -5232,13 +5840,6 @@ function applyExpectedProgressLive(state, now) {
   computeExpectedProgressLive(rootIds, now, state);
 }
 
-// src/propagations/shared/get-active-baseline.ts
-function getActiveBaseline(activity) {
-  const points = activity?.baselinePoints;
-  if (!Array.isArray(points) || points.length === 0) return null;
-  return points.find((point) => point.isActiveVersion) ?? null;
-}
-
 // src/columns/expected-progress-base/compute.ts
 var isProject2 = (a) => a.type === "project";
 var activeBaselineOf = (a) => getActiveBaseline(a);
@@ -5297,15 +5898,15 @@ function runExpectedProgressBase(state, now, defaultBaseCalendarId = null) {
 }
 
 // src/columns/status/constants.ts
-var DEFAULT_STATUS_CRITERIA = "Baseline";
+var DEFAULT_STATUS_CRITERIA = STATUS_CRITERIA.BASELINE;
 function resolveStatusCriteria(value) {
-  return value === "Actual" ? "Actual" : DEFAULT_STATUS_CRITERIA;
+  return value === STATUS_CRITERIA.ACTUAL ? STATUS_CRITERIA.ACTUAL : DEFAULT_STATUS_CRITERIA;
 }
 
 // src/columns/status/compute.ts
 var roundToTwoDecimals = (value) => Math.round(value * 100) / 100;
 function resolveExpectedForStatus(activity, criteria) {
-  const value = criteria === "Baseline" ? activity.expectedProgressBaseline : activity.expectedProgress;
+  const value = criteria === STATUS_CRITERIA.BASELINE ? activity.expectedProgressBaseline : activity.expectedProgress;
   return value ?? void 0;
 }
 function deriveActivityStatus(progress, expectedProgress) {
@@ -5432,7 +6033,7 @@ var CONSTRAINT_TYPES = Object.freeze({
 });
 
 // src/critical-path/legacy/constants/linkTypes.js
-var LINK_TYPES = Object.freeze({
+var LINK_TYPES2 = Object.freeze({
   FS: "fs",
   SS: "ss",
   FF: "ff",
@@ -5720,13 +6321,13 @@ function getMaxEarlyStartSet(arrayCalculatedLinks) {
 
 // src/critical-path/legacy/base/parents-calculations/helpers.js
 function mutateDate({
-  linkType,
+  linkType: linkType2,
   lag,
   predecessorTime,
   activityCalendar,
   activity
 }) {
-  if (linkType === LINK_TYPES.FS && lag === 0) {
+  if (linkType2 === LINK_TYPES2.FS && lag === 0) {
     return getNextWorkingHour({
       activityCalendar,
       direction: "future",
@@ -5735,7 +6336,7 @@ function mutateDate({
   } else {
     return mutateTheDateToFutureOrPastInBaseRestriction(
       predecessorTime,
-      linkType,
+      linkType2,
       activityCalendar,
       activity
     );
@@ -5762,10 +6363,10 @@ function calculateRestrictionSnet({
   return { es, ef };
 }
 function mutateTheDateToFutureOrPastInBaseRestriction(dateBaseToCalculate, restrictionOfLink, activityCalendar, activity) {
-  if (![LINK_TYPES.FS, LINK_TYPES.SS, LINK_TYPES.FF].includes(restrictionOfLink)) {
+  if (![LINK_TYPES2.FS, LINK_TYPES2.SS, LINK_TYPES2.FF].includes(restrictionOfLink)) {
     return dateBaseToCalculate;
   }
-  let constraintThatGoToNextWorkingHour = [LINK_TYPES.FS, LINK_TYPES.SS];
+  let constraintThatGoToNextWorkingHour = [LINK_TYPES2.FS, LINK_TYPES2.SS];
   let direction = constraintThatGoToNextWorkingHour.includes(restrictionOfLink) ? "future" : "past";
   return getNextWorkingHour({
     dateBaseToCalculate,
@@ -5805,18 +6406,18 @@ var CalculateForwardParentsWithLinks = class {
     const calculations = [];
     for (const linkedActivity of this.linkedActivitiesData) {
       const linkTypeCode = linkedActivity.linkType;
-      const linkType = getLinkNameByCode(linkTypeCode);
+      const linkType2 = getLinkNameByCode(linkTypeCode);
       const lag = linkedActivity.linkLag;
       const predecessorEs = linkedActivity.es;
       const predecessorEf = linkedActivity.ef;
       let calculation = null;
-      if (linkType === "ss") {
+      if (linkType2 === "ss") {
         calculation = this.calculateSSLink({ lag, predecessorEs });
-      } else if (linkType === "ff") {
+      } else if (linkType2 === "ff") {
         calculation = this.calculateFFLink({ lag, predecessorEf });
-      } else if (linkType === "fs") {
+      } else if (linkType2 === "fs") {
         calculation = this.calculateFSLink({ lag, predecessorEf });
-      } else if (linkType === "sf") {
+      } else if (linkType2 === "sf") {
         calculation = this.calculateSFLink({
           lag,
           predecessorEs,
@@ -5985,7 +6586,7 @@ var CalculateBackwardParentsLinks = class {
     }
     const calculationsFromLinks = [];
     for (let linkedActivity of this.linkedActivitiesData) {
-      const linkType = getLinkNameByCode(linkedActivity.linkType);
+      const linkType2 = getLinkNameByCode(linkedActivity.linkType);
       if (linkedActivity.type === "task" && Number(linkedActivity.progress) > 0) {
         continue;
       }
@@ -5995,7 +6596,7 @@ var CalculateBackwardParentsLinks = class {
       const lag = linkedActivity.linkLag;
       let sucessorLs = linkedActivity.ls;
       let sucessorLf = linkedActivity.lf;
-      if (linkType === "ss") {
+      if (linkType2 === "ss") {
         const valuesToDoCalculation = {
           lag,
           workTime: sucessorLs,
@@ -6005,7 +6606,7 @@ var CalculateBackwardParentsLinks = class {
         let { ls, lf } = this.calculateSSLink(valuesToDoCalculation);
         calculationsFromLinks.push({ ls, lf });
       }
-      if (linkType === "ff") {
+      if (linkType2 === "ff") {
         const valuesToDoCalculation = {
           lag,
           workTime: sucessorLf,
@@ -6015,7 +6616,7 @@ var CalculateBackwardParentsLinks = class {
         let { ls, lf } = this.calculateFFLink(valuesToDoCalculation);
         calculationsFromLinks.push({ ls, lf });
       }
-      if (linkType === "fs") {
+      if (linkType2 === "fs") {
         const valuesToDoCalculation = {
           lag,
           workTime: sucessorLs,
@@ -6025,7 +6626,7 @@ var CalculateBackwardParentsLinks = class {
         let { ls, lf } = this.calculateFsLink(valuesToDoCalculation);
         calculationsFromLinks.push({ ls, lf });
       }
-      if (linkType === "sf") {
+      if (linkType2 === "sf") {
         const valuesToDoCalculation = {
           lag,
           workTime: sucessorLf,
@@ -7215,7 +7816,7 @@ var LinksRulesCalculationsMethods = class {
     }
     return this.calculatedActivities.get(Number(activity));
   }
-  calculateSucessorTimes(predecessorTime, esDataCalculation, efDataCalculation = 0, lag, restrictionOfLink = LINK_TYPES.FS) {
+  calculateSucessorTimes(predecessorTime, esDataCalculation, efDataCalculation = 0, lag, restrictionOfLink = LINK_TYPES2.FS) {
     const activityCalendar = this.gantt.getCalendar(
       this.referenceActivity.calendar_id
     );
@@ -7229,7 +7830,7 @@ var LinksRulesCalculationsMethods = class {
     let ef = null;
     const isAMilestone = this.referenceActivity.type === "milestone";
     if (!isAMilestone) {
-      if (restrictionOfLink === LINK_TYPES.FS && lag === 0) {
+      if (restrictionOfLink === LINK_TYPES2.FS && lag === 0) {
         dateBaseToCalculate = getNextWorkingHour({
           dateBaseToCalculate,
           activityCalendar,
@@ -7244,7 +7845,7 @@ var LinksRulesCalculationsMethods = class {
         );
       }
     }
-    if ([LINK_TYPES.FF, LINK_TYPES.SF].includes(restrictionOfLink)) {
+    if ([LINK_TYPES2.FF, LINK_TYPES2.SF].includes(restrictionOfLink)) {
       ef = addDurationToDate(
         activityCalendar,
         dateBaseToCalculate,
@@ -7298,7 +7899,7 @@ var LinksRulesCalculationsMethods = class {
       esDataCalculation,
       efDataCalculation,
       lag,
-      LINK_TYPES.SS
+      LINK_TYPES2.SS
     );
   }
   calculateFF(link) {
@@ -7312,7 +7913,7 @@ var LinksRulesCalculationsMethods = class {
       esDataCalculation,
       efDataCalculation,
       lag,
-      LINK_TYPES.FF
+      LINK_TYPES2.FF
     );
   }
   calculateFS(link) {
@@ -7326,7 +7927,7 @@ var LinksRulesCalculationsMethods = class {
       esDataCalculation,
       efDataCalculation,
       lag,
-      LINK_TYPES.FS
+      LINK_TYPES2.FS
     );
   }
   calculateSF(link) {
@@ -7340,14 +7941,14 @@ var LinksRulesCalculationsMethods = class {
       esDataCalculation,
       efDataCalculation,
       lag,
-      LINK_TYPES.SF
+      LINK_TYPES2.SF
     );
   }
   mutateTheDateToFutureOrPastInBaseRestriction(dateBaseToCalculate, restrictionOfLink, activityCalendar) {
-    if (![LINK_TYPES.FS, LINK_TYPES.SS, LINK_TYPES.FF].includes(restrictionOfLink)) {
+    if (![LINK_TYPES2.FS, LINK_TYPES2.SS, LINK_TYPES2.FF].includes(restrictionOfLink)) {
       return dateBaseToCalculate;
     }
-    const constraintThatGoToNextWorkingHour = [LINK_TYPES.FS, LINK_TYPES.SS];
+    const constraintThatGoToNextWorkingHour = [LINK_TYPES2.FS, LINK_TYPES2.SS];
     const direction = constraintThatGoToNextWorkingHour.includes(
       restrictionOfLink
     ) ? "future" : "past";
@@ -7882,7 +8483,7 @@ var CalculationsGenericMethods = class {
     }
     return this.calculatedActivities.get(activity);
   }
-  calculateSuccessorTimes(sucessorTime, lsDataCalculation, lfDataCalculation = 0, lag, type = LINK_TYPES.FS) {
+  calculateSuccessorTimes(sucessorTime, lsDataCalculation, lfDataCalculation = 0, lag, type = LINK_TYPES2.FS) {
     let activityCalendar = this.gantt.getCalendar(this.activity.calendar_id);
     if (!activityCalendar) {
       throw new Error(
@@ -7914,19 +8515,19 @@ var CalculationsGenericMethods = class {
       lfDataCalculation,
       isMilestone
     };
-    if (type === LINK_TYPES.FS) {
+    if (type === LINK_TYPES2.FS) {
       let { ls, lf } = this.calculateFsLink(valuesToDoCalculation);
       return { ls, lf };
     }
-    if (type === LINK_TYPES.FF) {
+    if (type === LINK_TYPES2.FF) {
       let { ls, lf } = this.calculateFFLink(valuesToDoCalculation);
       return { ls, lf };
     }
-    if (type === LINK_TYPES.SS) {
+    if (type === LINK_TYPES2.SS) {
       let { ls, lf } = this.calculateSSlink(valuesToDoCalculation);
       return { ls, lf };
     }
-    if (type === LINK_TYPES.SF) {
+    if (type === LINK_TYPES2.SF) {
       let { ls, lf } = this.calculateSFLink(valuesToDoCalculation);
       return { ls, lf };
     }
@@ -7941,7 +8542,7 @@ var CalculationsGenericMethods = class {
       lsDataForCalculation,
       lfDataForCalculation,
       lag,
-      LINK_TYPES.SS
+      LINK_TYPES2.SS
     );
   }
   calculateFF(link, constraint) {
@@ -7958,7 +8559,7 @@ var CalculationsGenericMethods = class {
       lsDataForCalculation,
       lfDataForCalculation,
       lag,
-      LINK_TYPES.FF
+      LINK_TYPES2.FF
     );
   }
   calculateFS(link, constraint) {
@@ -7976,7 +8577,7 @@ var CalculationsGenericMethods = class {
       lsDataForCalculation,
       lfDataForCalculation,
       lag,
-      LINK_TYPES.FS
+      LINK_TYPES2.FS
     );
   }
   calculateSF(link, getFromForward = false) {
@@ -7989,7 +8590,7 @@ var CalculationsGenericMethods = class {
       lsDataForCalculation,
       lfDataForCalculation,
       lag,
-      LINK_TYPES.SF
+      LINK_TYPES2.SF
     );
   }
   getEarlyStartFromForwardPath(link) {
@@ -9177,7 +9778,7 @@ var FreeFloat = class {
     }
     return constraint_type;
   }
-  getDatesFromSucessorAndPredecessor(linkType, constraint, sucessor) {
+  getDatesFromSucessorAndPredecessor(linkType2, constraint, sucessor) {
     const isSuscessorAlap = sucessor.constraint_type === CONSTRAINT_TYPES.ALAP;
     const constraintData = this.getSucessorAndPredecessorDates({
       constraint,
@@ -9187,8 +9788,8 @@ var FreeFloat = class {
     });
     let sucessorDateToCalculate = /* @__PURE__ */ new Date();
     let predecessorDateToCalculate = /* @__PURE__ */ new Date();
-    sucessorDateToCalculate = constraintData[linkType].sucessor;
-    predecessorDateToCalculate = constraintData[linkType].predecessor;
+    sucessorDateToCalculate = constraintData[linkType2].sucessor;
+    predecessorDateToCalculate = constraintData[linkType2].predecessor;
     return {
       sucessorDateToCalculate,
       predecessorDateToCalculate
@@ -10360,10 +10961,10 @@ function detectSirAutoReject(beforeSnap, adapter, touchedIds) {
     if (adapter.getActivity(id) != null) continue;
     for (const pending of pendingRequestIds) {
       effects.push({
-        kind: "sir-auto-reject",
+        kind: SCHEDULE_EFFECT_KIND.SIR_AUTO_REJECT,
         activityId: id,
         sirId: pending,
-        reason: "activity_deleted"
+        reason: SIR_AUTO_REJECT_REASON.ACTIVITY_DELETED
       });
     }
   }
@@ -10804,11 +11405,57 @@ async function dispatchInlineEdit(action, options, deps) {
 }
 
 // src/dispatch/handlers/link.ts
+var LINK_TYPE_VALUES = new Set(Object.values(LINK_TYPE));
+function isValidLinkType(value) {
+  return typeof value === "string" && LINK_TYPE_VALUES.has(value);
+}
+function hasOwn(value, property) {
+  return Object.hasOwn(value, property);
+}
+function validateLinkAction(action) {
+  if (action.kind === DISPATCH_ACTION_KIND.LINK_CREATE) {
+    if (!isValidLinkType(action.type)) {
+      return REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    return action.lag === void 0 || Number.isFinite(action.lag) ? null : REJECTION_REASON.INVALID_LINK_LAG;
+  }
+  if (action.kind === DISPATCH_ACTION_KIND.LINK_UPDATE) {
+    if (hasOwn(action, "type") && !isValidLinkType(action.type)) {
+      return REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    if (hasOwn(action, "lag") && !Number.isFinite(action.lag)) {
+      return REJECTION_REASON.INVALID_LINK_LAG;
+    }
+  }
+  return null;
+}
+function validateLinkBatchOperation(operation) {
+  if (operation.kind === DISPATCH_LINK_OPERATION_KIND.CREATE) {
+    if (!isValidLinkType(operation.type)) {
+      return REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    return operation.lag === void 0 || Number.isFinite(operation.lag) ? null : REJECTION_REASON.INVALID_LINK_LAG;
+  }
+  if (operation.kind === DISPATCH_LINK_OPERATION_KIND.UPDATE) {
+    if (hasOwn(operation, "type") && !isValidLinkType(operation.type)) {
+      return REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    return !hasOwn(operation, "lag") || Number.isFinite(operation.lag) ? null : REJECTION_REASON.INVALID_LINK_LAG;
+  }
+  return operation.kind === DISPATCH_LINK_OPERATION_KIND.DELETE ? null : REJECTION_REASON.INVALID_VALUE;
+}
+function validateLinkBatch(operations) {
+  for (const operation of operations) {
+    const error = validateLinkBatchOperation(operation);
+    if (error !== null) return error;
+  }
+  return null;
+}
 function collectBatchContext(operations, adapter) {
   const activityIds = /* @__PURE__ */ new Set();
   const links = /* @__PURE__ */ new Map();
   for (const operation of operations) {
-    if (operation.kind === "create") {
+    if (operation.kind === DISPATCH_LINK_OPERATION_KIND.CREATE) {
       activityIds.add(String(operation.source));
       activityIds.add(String(operation.target));
       continue;
@@ -10823,7 +11470,7 @@ function collectBatchContext(operations, adapter) {
 }
 function applyBatchOperations(operations, adapter, linkIdGen, deterministicIds) {
   return operations.map((operation, index) => {
-    const deterministicId = operation.kind === "create" ? deterministicIds?.get(index) : void 0;
+    const deterministicId = operation.kind === DISPATCH_LINK_OPERATION_KIND.CREATE ? deterministicIds?.get(index) : void 0;
     const result = applyLinkOperation(operation, {
       port: adapter,
       newLinkId: deterministicId ? () => deterministicId : linkIdGen.next
@@ -10831,7 +11478,7 @@ function applyBatchOperations(operations, adapter, linkIdGen, deterministicIds)
     return {
       op: operation,
       finalLinkId: result.applied ? result.linkId : null,
-      rejected: result.applied ? null : result.rejected ?? "link_op_rejected"
+      rejected: result.applied ? null : result.rejected ?? REJECTION_REASON.INVALID
     };
   });
 }
@@ -10839,25 +11486,19 @@ function stringKeyedLinkSnapshots(links) {
   return new Map([...links].map(([id, link]) => [String(id), link]));
 }
 async function dispatchLink(action, options, deps) {
-  if (action.kind === "link-create" || action.kind === "link-update") {
-    const type = action.type;
-    if (type !== void 0 && !Object.values(LINK_TYPE).some((t) => t === type)) {
-      return { ok: false, reason: REJECTION_REASON.INVALID_LINK_TYPE };
-    }
-    const lag = action.lag;
-    if (lag !== void 0 && !Number.isFinite(lag)) {
-      return { ok: false, reason: REJECTION_REASON.INVALID_LINK_LAG };
-    }
-  }
+  const validationError = validateLinkAction(action);
+  if (validationError !== null) return { ok: false, reason: validationError };
   return dispatchLinkBatch(
     [toLinkOperation(action, deps.sector.hoursPerDay)],
     action,
     options,
     deps,
-    action.kind === "link-create" && action.linkId ? /* @__PURE__ */ new Map([[0, action.linkId]]) : void 0
+    action.kind === DISPATCH_ACTION_KIND.LINK_CREATE && action.linkId ? /* @__PURE__ */ new Map([[0, action.linkId]]) : void 0
   );
 }
 async function dispatchLinksBatch(action, options, deps) {
+  const validationError = validateLinkBatch(action.operations);
+  if (validationError !== null) return { ok: false, reason: validationError };
   const { hoursPerDay } = deps.sector;
   const operations = action.operations.map(
     (op) => batchOpToLinkOperation(op, hoursPerDay)
@@ -10868,7 +11509,9 @@ async function dispatchLinksBatch(action, options, deps) {
 function collectDeterministicIds(operations) {
   const ids = /* @__PURE__ */ new Map();
   operations.forEach((op, index) => {
-    if (op.kind === "create" && op.linkId) ids.set(index, op.linkId);
+    if (op.kind === DISPATCH_LINK_OPERATION_KIND.CREATE && op.linkId) {
+      ids.set(index, op.linkId);
+    }
   });
   return ids.size > 0 ? ids : void 0;
 }
@@ -10893,24 +11536,24 @@ function resolveDeterministicIds(deterministicIds, deps) {
   return resolved;
 }
 function batchOpToLinkOperation(op, hoursPerDay) {
-  if (op.kind === "create") {
+  if (op.kind === DISPATCH_LINK_OPERATION_KIND.CREATE) {
     return {
-      kind: "create",
+      kind: DISPATCH_LINK_OPERATION_KIND.CREATE,
       source: op.source,
       target: op.target,
       type: op.type,
       lag: lagDaysToHours(op.lag ?? 0, hoursPerDay)
     };
   }
-  if (op.kind === "update") {
+  if (op.kind === DISPATCH_LINK_OPERATION_KIND.UPDATE) {
     return {
-      kind: "update",
+      kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
       linkId: op.linkId,
       type: op.type,
       lag: op.lag === void 0 ? void 0 : lagDaysToHours(op.lag, hoursPerDay)
     };
   }
-  return { kind: "delete", linkId: op.linkId };
+  return { kind: DISPATCH_LINK_OPERATION_KIND.DELETE, linkId: op.linkId };
 }
 async function dispatchLinkBatch(operations, source, options, deps, deterministicIds) {
   const { adapter, scheduler, sector, linkIdGen } = deps;
@@ -10926,7 +11569,7 @@ async function dispatchLinkBatch(operations, source, options, deps, deterministi
     linkIdGen,
     resolveDeterministicIds(deterministicIds, deps)
   );
-  if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== "inline-edit") {
+  if (operations.length === 1 && applied[0] && applied[0].rejected !== null && source.kind !== DISPATCH_ACTION_KIND.INLINE_EDIT) {
     return { ok: false, reason: applied[0].rejected };
   }
   const triggerId = pickAutoscheduleTrigger(applied, beforeLinks, adapter);
@@ -10982,31 +11625,36 @@ function pickAutoscheduleTrigger(applied, beforeLinks, adapter) {
   return null;
 }
 function autoscheduleTarget(operation, beforeLinks, adapter) {
-  if (operation.kind === "create") return operation.target;
-  if (operation.kind === "delete") {
+  if (operation.kind === DISPATCH_LINK_OPERATION_KIND.CREATE) {
+    return operation.target;
+  }
+  if (operation.kind === DISPATCH_LINK_OPERATION_KIND.DELETE) {
     return beforeLinks.get(operation.linkId)?.target ?? null;
   }
   return adapter.getLink(operation.linkId)?.target ?? null;
 }
 function toLinkOperation(action, hoursPerDay) {
-  if (action.kind === "link-create") {
+  if (action.kind === DISPATCH_ACTION_KIND.LINK_CREATE) {
     return {
-      kind: "create",
+      kind: DISPATCH_LINK_OPERATION_KIND.CREATE,
       source: action.source,
       target: action.target,
       type: action.type,
-      lag: lagDaysToHours(action.lag, hoursPerDay)
+      lag: lagDaysToHours(action.lag ?? 0, hoursPerDay)
     };
   }
-  if (action.kind === "link-update") {
+  if (action.kind === DISPATCH_ACTION_KIND.LINK_UPDATE) {
     return {
-      kind: "update",
+      kind: DISPATCH_LINK_OPERATION_KIND.UPDATE,
       linkId: action.linkId,
       type: action.type,
       lag: action.lag === void 0 ? void 0 : lagDaysToHours(action.lag, hoursPerDay)
     };
   }
-  return { kind: "delete", linkId: action.linkId };
+  return {
+    kind: DISPATCH_LINK_OPERATION_KIND.DELETE,
+    linkId: action.linkId
+  };
 }
 async function dispatchInlineEditLinks(action, options, deps) {
   const { adapter, sector } = deps;
@@ -12132,16 +12780,16 @@ async function dispatchActivityBatch(action, options, deps) {
   if (validationError) return { ok: false, reason: validationError };
   const plan = buildBatchPlan(action, deps);
   if (!plan.ok) return plan;
-  const existingActivityIds = action.mode === "replace" ? new Set(deps.adapter.getAllIds().map((id) => String(id))) : /* @__PURE__ */ new Set();
-  const beforeSnap = action.mode === "replace" ? await snapshotActivities(deps.adapter, existingActivityIds) : /* @__PURE__ */ new Map();
-  const beforeLinks = action.mode === "replace" ? snapshotAllLinks(deps) : /* @__PURE__ */ new Map();
-  const viewState = action.mode === "replace" ? captureDeletedViewState(deps.adapter, existingActivityIds) : [];
+  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();
+  const viewState = action.mode === ACTIVITY_BATCH_MODE.REPLACE ? captureDeletedViewState(deps.adapter, existingActivityIds) : [];
   deps.scheduler.invalidateAllCaches();
   const appliedLinks = [];
-  if (action.mode === "replace") {
+  if (action.mode === ACTIVITY_BATCH_MODE.REPLACE) {
     for (const linkId of beforeLinks.keys()) {
       const deleted = applyLinkOperation(
-        { kind: "delete", linkId },
+        { kind: DISPATCH_LINK_OPERATION_KIND.DELETE, linkId },
         { port: deps.adapter }
       );
       if (!deleted.applied) {
@@ -12151,7 +12799,7 @@ async function dispatchActivityBatch(action, options, deps) {
         };
       }
       appliedLinks.push({
-        op: { kind: "delete", linkId },
+        op: { kind: DISPATCH_LINK_OPERATION_KIND.DELETE, linkId },
         finalLinkId: linkId,
         rejected: null
       });
@@ -12173,7 +12821,7 @@ async function dispatchActivityBatch(action, options, deps) {
   const existingCorrelativeShifts = correlativeShifts.filter(
     (shift) => !createdIdSet.has(shift.activityId)
   );
-  const touchedIds = action.mode === "replace" ? new Set(existingActivityIds) : /* @__PURE__ */ new Set();
+  const touchedIds = action.mode === ACTIVITY_BATCH_MODE.REPLACE ? new Set(existingActivityIds) : /* @__PURE__ */ new Set();
   foldCorrelativeShifts(
     deps.adapter,
     correlativeShifts,
@@ -12186,11 +12834,11 @@ async function dispatchActivityBatch(action, options, deps) {
   }
   const linkCreates = plan.plan.links.map((link) => ({
     operation: {
-      kind: "create",
+      kind: DISPATCH_LINK_OPERATION_KIND.CREATE,
       source: link.source,
       target: link.target,
       type: link.type,
-      lag: lagDaysToHours(link.lag, deps.sector.hoursPerDay)
+      lag: lagDaysToHours(link.lag ?? 0, deps.sector.hoursPerDay)
     },
     linkId: link.linkId
   }));
@@ -12235,19 +12883,19 @@ async function dispatchActivityBatch(action, options, deps) {
     links: buildLinkChangesForBatch(appliedLinks, beforeLinks, deps.adapter),
     hoursPerDay: deps.sector.hoursPerDay,
     correlativeShifts: existingCorrelativeShifts,
-    ...action.mode === "replace" ? { sirDetection: "after-diff" } : {}
+    ...action.mode === ACTIVITY_BATCH_MODE.REPLACE ? { sirDetection: "after-diff" } : {}
   });
   return {
     ok: true,
     changes: viewState.length > 0 ? { ...changes, viewState } : changes,
-    ...action.mode === "replace" ? {
+    ...action.mode === ACTIVITY_BATCH_MODE.REPLACE ? {
       __beforeSnap: beforeSnap,
       __beforeLinks: stringKeyedLinks(beforeLinks)
     } : {}
   };
 }
 function validateBatch(action, deps) {
-  if (action.mode !== "append" && action.mode !== "replace") {
+  if (action.mode !== ACTIVITY_BATCH_MODE.APPEND && action.mode !== ACTIVITY_BATCH_MODE.REPLACE) {
     return REJECTION_REASON.INVALID;
   }
   const batchIds = /* @__PURE__ */ new Set();
@@ -12262,7 +12910,7 @@ function validateBatch(action, deps) {
     }
     if (item.activityId !== void 0) {
       const activityId = String(item.activityId);
-      if (activityId.length === 0 || activityId === "0" || explicitActivityIds.has(activityId)) {
+      if (activityId.length === 0 || activityId === ROOT_PARENT_ID || explicitActivityIds.has(activityId)) {
         return REJECTION_REASON.INVALID;
       }
       explicitActivityIds.add(activityId);
@@ -12276,8 +12924,11 @@ function validateBatch(action, deps) {
   if (hasParentCycle(action.items)) return REJECTION_REASON.INVALID;
   const explicitLinkIds = /* @__PURE__ */ new Set();
   for (const link of action.links) {
-    if (!Object.values(LINK_TYPE).includes(link.type) || !Number.isFinite(link.lag)) {
-      return !Number.isFinite(link.lag) ? REJECTION_REASON.INVALID_LINK_LAG : REJECTION_REASON.INVALID_LINK_TYPE;
+    if (!Object.values(LINK_TYPE).includes(link.type)) {
+      return REJECTION_REASON.INVALID_LINK_TYPE;
+    }
+    if (link.lag !== void 0 && !Number.isFinite(link.lag)) {
+      return REJECTION_REASON.INVALID_LINK_LAG;
     }
     if (!validReference(link.source, false, action.mode, batchIds, deps) || !validReference(link.target, false, action.mode, batchIds, deps)) {
       return REJECTION_REASON.ACTIVITY_NOT_FOUND;
@@ -12294,8 +12945,8 @@ function validateBatch(action, deps) {
 }
 function validReference(reference, allowRoot, mode, batchIds, deps) {
   if (typeof reference === "string") {
-    if (reference === "0") return allowRoot;
-    return mode === "append" && deps.adapter.getActivity(String(reference)) !== null;
+    if (reference === ROOT_PARENT_ID) return allowRoot;
+    return mode === ACTIVITY_BATCH_MODE.APPEND && deps.adapter.getActivity(String(reference)) !== null;
   }
   return reference !== null && reference.batchId.length > 0 && batchIds.has(reference.batchId);
 }
@@ -12390,32 +13041,32 @@ function buildBatchPlan(action, deps) {
       source,
       target,
       type: link.type,
-      lag: link.lag,
+      lag: link.lag ?? 0,
       linkId
     });
   }
   return { ok: true, plan: { items, links } };
 }
 function resolvePlannedActivityId(explicitId, mode, plannedIds, deps) {
-  const explicitIsAvailable = explicitId !== void 0 && (mode === "replace" || deps.adapter.getActivity(explicitId) === null && !deps.isActivityIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
+  const explicitIsAvailable = explicitId !== void 0 && (mode === ACTIVITY_BATCH_MODE.REPLACE || deps.adapter.getActivity(explicitId) === null && !deps.isActivityIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
   if (explicitIsAvailable) {
     deps.activityIdGen.bump(explicitId);
     return explicitId;
   }
   let candidate = deps.activityIdGen.next();
-  while (plannedIds.has(String(candidate)) || mode === "append" && (deps.adapter.getActivity(candidate) !== null || deps.isActivityIdReserved(String(candidate)))) {
+  while (plannedIds.has(String(candidate)) || mode === ACTIVITY_BATCH_MODE.APPEND && (deps.adapter.getActivity(candidate) !== null || deps.isActivityIdReserved(String(candidate)))) {
     candidate = deps.activityIdGen.next();
   }
   return candidate;
 }
 function resolvePlannedLinkId(explicitId, mode, plannedIds, deps) {
-  const explicitIsAvailable = explicitId !== void 0 && (mode === "replace" || deps.adapter.getLink(explicitId) === null && !deps.isLinkIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
+  const explicitIsAvailable = explicitId !== void 0 && (mode === ACTIVITY_BATCH_MODE.REPLACE || deps.adapter.getLink(explicitId) === null && !deps.isLinkIdReserved(String(explicitId))) && !plannedIds.has(String(explicitId));
   if (explicitIsAvailable) {
     deps.linkIdGen.bump(explicitId);
     return explicitId;
   }
   let candidate = deps.linkIdGen.next();
-  while (plannedIds.has(String(candidate)) || mode === "append" && (deps.adapter.getLink(candidate) !== null || deps.isLinkIdReserved(String(candidate)))) {
+  while (plannedIds.has(String(candidate)) || mode === ACTIVITY_BATCH_MODE.APPEND && (deps.adapter.getLink(candidate) !== null || deps.isLinkIdReserved(String(candidate)))) {
     candidate = deps.linkIdGen.next();
   }
   return candidate;
@@ -12442,7 +13093,7 @@ function planInsertionCorrelatives(action, activityIdsByBatchId, deps) {
     const parentKey = String(parentId);
     let plan = plansByParent.get(parentKey);
     if (!plan) {
-      const existing = action.mode === "replace" || typeof item.parent !== "string" && activityIdsByBatchId.has(item.parent.batchId) ? [] : collectSiblings(deps.adapter, parentKey).sort((left, right) => {
+      const existing = action.mode === ACTIVITY_BATCH_MODE.REPLACE || typeof item.parent !== "string" && activityIdsByBatchId.has(item.parent.batchId) ? [] : collectSiblings(deps.adapter, parentKey).sort((left, right) => {
         const diff = readCorrelativeId(left) - readCorrelativeId(right);
         return diff || String(left.id).localeCompare(String(right.id));
       }).map((activity) => String(activity.id));
@@ -12495,8 +13146,8 @@ function planInsertionCorrelatives(action, activityIdsByBatchId, deps) {
   return result;
 }
 function isSimpleRootAppend(action) {
-  return action.mode === "append" && action.items.every(
-    (item) => item.parent === "0" && item.index === void 0
+  return action.mode === ACTIVITY_BATCH_MODE.APPEND && action.items.every(
+    (item) => item.parent === ROOT_PARENT_ID && item.index === void 0
   );
 }
 function activityCorrelative(activityId, deps) {
@@ -12527,6 +13178,7 @@ async function createPlannedActivities(action, plannedItems, deps) {
     const item = ready[index];
     const core = await createActivityCore(
       {
+        kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
         parentId: item.parentId,
         activityId: item.activityId,
         overrides: item.overrides,
@@ -12552,7 +13204,9 @@ async function createPlannedActivities(action, plannedItems, deps) {
   const recomputedParents = /* @__PURE__ */ new Set();
   for (let index = ready.length - 1; index >= 0; index -= 1) {
     const parentId = ready[index].parentId;
-    if (parentId === "0" || recomputedParents.has(String(parentId))) continue;
+    if (parentId === ROOT_PARENT_ID || recomputedParents.has(String(parentId))) {
+      continue;
+    }
     recomputedParents.add(String(parentId));
     recomputeRollupCascadesForParent(parentId, deps.adapter);
   }
@@ -13704,7 +14358,13 @@ async function dispatchActivitySetProgress(action, options, deps) {
 }
 
 // src/dispatch/handlers/dates-batch.ts
+function isDateColumn(column) {
+  return column === COLUMN.START_DATE || column === COLUMN.END_DATE;
+}
 async function dispatchDatesBatch(action, options, deps) {
+  if (action.edits.some((edit) => !isDateColumn(edit.column))) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
   const { adapter, scheduler, sector } = deps;
   const verdicts = [];
   const beforeSnap = /* @__PURE__ */ new Map();
@@ -14221,7 +14881,7 @@ function applyBaselineOverlay(state, points, now, reporter, defaultBaseCalendarI
 
 // src/propagations/downward/recompute-ponderator-for-parent.ts
 function recomputePonderatorsForParent(parentId, criterion, adapter) {
-  if (!parentId || parentId === "0") return;
+  if (!parentId || parentId === ROOT_PARENT_ID) return;
   const childIds = adapter.getChildren(parentId);
   if (childIds.length === 0) return;
   const pesoById = /* @__PURE__ */ new Map();
@@ -14254,12 +14914,16 @@ function criterionValue(childId, criterion, adapter) {
   if (!child) return 0;
   const active = getActiveBaseline(child);
   if (!active) return 0;
-  if (criterion === "COST") return toNumber(active.cost);
-  if (criterion === "HH") return toNumber(active.workHours);
-  const type = child.type;
-  if (type === "project")
+  if (criterion === ACTIVITY_PONDERATOR_CRITERION.COST) {
+    return toNumber(active.cost);
+  }
+  if (criterion === ACTIVITY_PONDERATOR_CRITERION.WORK_HOURS) {
+    return toNumber(active.workHours);
+  }
+  const { type } = child;
+  if (type === ACTIVITY_TYPE.PROJECT)
     return sumRecursiveBaselineDurationDays(childId, adapter);
-  if (type === "milestone") return 0;
+  if (type === ACTIVITY_TYPE.MILESTONE) return 0;
   return toNumber(active.durationDays);
 }
 function sumRecursiveBaselineDurationDays(activityId, adapter) {
@@ -14269,10 +14933,10 @@ function sumRecursiveBaselineDurationDays(activityId, adapter) {
     if (!child) continue;
     const active = getActiveBaseline(child);
     if (!active) continue;
-    const type = child.type;
-    if (type === "project") {
+    const { type } = child;
+    if (type === ACTIVITY_TYPE.PROJECT) {
       sum += sumRecursiveBaselineDurationDays(String(childId), adapter);
-    } else if (type !== "milestone") {
+    } else if (type !== ACTIVITY_TYPE.MILESTONE) {
       sum += toNumber(active.durationDays);
     }
   }
@@ -14347,7 +15011,7 @@ async function dispatchBaselineApply(action, deps) {
   if (activeBaselineSignature(deps) !== activeBaselineBefore) {
     recomputeBaselineWeightedFields(
       deps,
-      deps.sector.activityCreter ?? "DURATION"
+      deps.sector.activityCreter ?? ACTIVITY_PONDERATOR_CRITERION.DURATION
     );
   }
   return {
@@ -14363,14 +15027,15 @@ async function dispatchBaselineApply(action, deps) {
 }
 
 // src/dispatch/handlers/ponderator-criterion-set.ts
-function assertValidCriterion(value) {
-  if (value === "DURATION" || value === "COST" || value === "HH") return;
-  throw new Error(
-    `ponderator-criterion-set: invalid criterion "${String(value)}"`
+function isValidCriterion(value) {
+  return Object.values(ACTIVITY_PONDERATOR_CRITERION).includes(
+    value
   );
 }
 async function dispatchPonderatorCriterionSet(action, deps) {
-  assertValidCriterion(action.criterion);
+  if (!isValidCriterion(action.criterion)) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
   const allIds = new Set(deps.adapter.getAllIds());
   const beforeSnap = await snapshotActivities(deps.adapter, allIds);
   recomputeBaselineWeightedFields(deps, action.criterion);
@@ -14406,6 +15071,64 @@ async function dispatchStatusCriteriaSet(action, deps) {
   };
 }
 
+// src/dispatch/handlers/calendar-reconcile.ts
+async function dispatchCalendarReconcile(action, options, deps) {
+  const beforeSnap = /* @__PURE__ */ new Map();
+  const touchedIds = /* @__PURE__ */ new Set();
+  for (const activity of deps.adapter.getAllActivities()) {
+    if (!shouldReconcile(activity, deps)) continue;
+    const calendar = deps.ctx.calendars.getCalendar(activity.calendarId);
+    if (!calendar) continue;
+    const startDate = calendar.getClosestWorkTime({
+      date: activity.startDate,
+      direction: WORK_TIME_DIRECTION.FUTURE,
+      unit: CALENDAR_UNIT.HOUR
+    });
+    const endDate = calendar.calculateEndDate(
+      startDate,
+      activity.durationHours
+    );
+    if (sameInstant(startDate, activity.startDate) && sameInstant(endDate, activity.endDate)) {
+      continue;
+    }
+    const activityId = String(activity.id);
+    beforeSnap.set(activityId, structuredCloneActivity(activity));
+    touchedIds.add(activityId);
+    deps.adapter.setActivityFields(activityId, { startDate, endDate });
+  }
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: "roots",
+      recomputeParentsFrom: touchedIds,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap,
+      touchedIds,
+      scheduledIds,
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+function shouldReconcile(activity, deps) {
+  return activity.progress === 0 && !isSummary(activity.type, deps.adapter.hasChildren(activity.id));
+}
+function sameInstant(first, second) {
+  return first.getTime() === second.getTime();
+}
+
 // src/activity-copy-paste/policy.ts
 var ACTIVITY_COPY_FIELDS = [
   "name",
@@ -14615,6 +15338,9 @@ async function performDispatch(action, options, deps) {
       clipboard: deps.activityClipboard
     });
   }
+  if (action.kind === "calendar-reconcile") {
+    return dispatchCalendarReconcile(action, options, deps);
+  }
   if (action.kind === "activity-clipboard-clear") {
     return dispatchActivityClipboardClear(action, deps.activityClipboard);
   }
@@ -18535,7 +19261,7 @@ function captureCreatedSnapshots(state, changeSet) {
   return { afterSnap, afterLinks };
 }
 function computeCoalesceKey(action) {
-  if (action.kind !== "inline-edit") return null;
+  if (action.kind !== DISPATCH_ACTION_KIND.INLINE_EDIT) return null;
   if (!NON_SCHEDULING_INLINE_COLUMNS.has(action.column)) return null;
   return `inline-edit:${String(action.activityId)}:${action.column}`;
 }
@@ -18570,10 +19296,10 @@ function mergeCoalesced(top, next) {
   return buildUndoEntry(changeSet);
 }
 function getDispatchHistoryPolicy(action) {
-  if (action.kind === "persistence-acknowledge") {
+  if (action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
     return "checkpoint-on-success";
   }
-  if (action.kind === "sir-sync" || action.kind === "activity-lookahead-sync" || action.kind === "baseline-apply" || action.kind === "ponderator-criterion-set" || action.kind === "status-criteria-set" || action.kind === "activity-clipboard-clear" || action.kind === "activity-copy" || action.kind === "selection-toggle" || action.kind === "selection-replace" || action.kind === "visibility-set" || action.kind === "filter-set" || action.kind === "sort-set") {
+  if (action.kind === DISPATCH_ACTION_KIND.SIR_SYNC || action.kind === DISPATCH_ACTION_KIND.CALENDAR_RECONCILE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC || action.kind === DISPATCH_ACTION_KIND.BASELINE_APPLY || action.kind === DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET || action.kind === DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_COPY || action.kind === DISPATCH_ACTION_KIND.SELECTION_TOGGLE || action.kind === DISPATCH_ACTION_KIND.SELECTION_REPLACE || action.kind === DISPATCH_ACTION_KIND.VISIBILITY_SET || action.kind === DISPATCH_ACTION_KIND.FILTER_SET || action.kind === DISPATCH_ACTION_KIND.SORT_SET) {
     return "skip";
   }
   return "record";
@@ -18661,7 +19387,9 @@ function buildInverseChangeSet(state, entry, side) {
     (change) => side === "before" ? invertViewStateChange(change) : change
   );
   return {
-    source: { kind: side === "before" ? "undo" : "redo" },
+    source: {
+      kind: side === "before" ? CHANGE_SET_SOURCE_KIND.UNDO : CHANGE_SET_SOURCE_KIND.REDO
+    },
     activities,
     links,
     calendars: [],
@@ -19496,7 +20224,7 @@ var WORKING_DAY_TRUE_VALUES = /* @__PURE__ */ new Set([
   "1",
   "true"
 ]);
-var DEFAULT_ACTIVITY_CRETER = "DURATION";
+var DEFAULT_ACTIVITY_CRETER = ACTIVITY_PONDERATOR_CRITERION.DURATION;
 var DEFAULT_CONSTRAINT_TYPE = "asap";
 var CONSTRAINT_LABEL_MAP = {
   ASAP: "asap",
@@ -20003,12 +20731,12 @@ function linkIdAsNumber(link) {
 function parseActivityCreter(raw) {
   if (typeof raw !== "string") return DEFAULT_ACTIVITY_CRETER;
   switch (raw.toUpperCase()) {
-    case "DURATION":
-      return "DURATION";
-    case "COST":
-      return "COST";
-    case "HH":
-      return "HH";
+    case ACTIVITY_PONDERATOR_CRITERION.DURATION:
+      return ACTIVITY_PONDERATOR_CRITERION.DURATION;
+    case ACTIVITY_PONDERATOR_CRITERION.COST:
+      return ACTIVITY_PONDERATOR_CRITERION.COST;
+    case ACTIVITY_PONDERATOR_CRITERION.WORK_HOURS:
+      return ACTIVITY_PONDERATOR_CRITERION.WORK_HOURS;
     default:
       return DEFAULT_ACTIVITY_CRETER;
   }
@@ -20735,8 +21463,8 @@ function compareByRule(rule, context) {
     const valueB = descriptor.extract(b, context);
     const missing = compareMissing(isMissing(valueA), isMissing(valueB));
     if (missing !== null) return missing;
-    const result = descriptor.valueKind === "enum" ? enumRank(valueA, descriptor.order) - enumRank(valueB, descriptor.order) : compareValues(valueA, valueB, context.locale);
-    return rule.direction === "desc" ? -result : result;
+    const result = descriptor.valueKind === FILTER_VALUE_KIND.ENUM ? enumRank(valueA, descriptor.order) - enumRank(valueB, descriptor.order) : compareValues(valueA, valueB, context.locale);
+    return rule.direction === ORDER_DIRECTION.DESCENDING ? -result : result;
   };
 }
 function buildComparator(order, context) {
@@ -21107,7 +21835,7 @@ function viewStateChanges(target, source) {
 function createProjectionChangeSet(target, source) {
   const orderChanged = serializeCanonicalSchedule(target.order) !== serializeCanonicalSchedule(source.order);
   return {
-    source: { kind: "init" },
+    source: { kind: CHANGE_SET_SOURCE_KIND.INIT },
     activities: entityChanges(target.activities, source.activities),
     links: entityChanges(target.links, source.links),
     calendars: entityChanges(target.calendars, source.calendars),
@@ -21119,6 +21847,11 @@ function createProjectionChangeSet(target, source) {
 }
 
 // src/propagations/upward/date-gesture-preview.ts
+var DATE_GESTURE_KIND = {
+  MOVE: "move",
+  RESIZE_START: "resize-start",
+  RESIZE_END: "resize-end"
+};
 var emptyFormula = () => ({
   constantStart: null,
   variableStartOffset: null,
@@ -21130,7 +21863,7 @@ var max = (left, right) => left === null ? right : Math.max(left, right);
 function createDateGesturePreview(adapter, gesture, assertCurrent) {
   const participantIds = [
     ...new Set(
-      gesture.kind === "move" ? gesture.activityIds.map(String) : [String(gesture.activityId)]
+      gesture.kind === DATE_GESTURE_KIND.MOVE ? gesture.activityIds.map(String) : [String(gesture.activityId)]
     )
   ];
   if (participantIds.length === 0) {
@@ -21159,14 +21892,14 @@ function createDateGesturePreview(adapter, gesture, assertCurrent) {
 }
 function buildParticipantFormulas(adapter, gesture, participantIds) {
   const formulas = /* @__PURE__ */ new Map();
-  const anchorId = gesture.kind === "move" ? String(gesture.anchorActivityId) : null;
+  const anchorId = gesture.kind === DATE_GESTURE_KIND.MOVE ? String(gesture.anchorActivityId) : null;
   const anchor = anchorId === null ? null : requireLeafActivity(adapter, anchorId);
   if (anchorId !== null && !participantIds.includes(anchorId)) {
     throw new Error("[ScheduleCore] move anchor is not a participant");
   }
   for (const activityId of participantIds) {
     const activity = requireLeafActivity(adapter, activityId);
-    if (gesture.kind === "move") {
+    if (gesture.kind === DATE_GESTURE_KIND.MOVE) {
       const anchorStart = anchor.startDate.getTime();
       formulas.set(activityId, {
         constantStart: null,
@@ -21174,7 +21907,7 @@ function buildParticipantFormulas(adapter, gesture, participantIds) {
         constantEnd: null,
         variableEndOffset: activity.endDate.getTime() - anchorStart
       });
-    } else if (gesture.kind === "resize-start") {
+    } else if (gesture.kind === DATE_GESTURE_KIND.RESIZE_START) {
       formulas.set(activityId, {
         constantStart: null,
         variableStartOffset: 0,
@@ -21265,7 +21998,7 @@ function evaluateEnd(formula, proposedEdgeTimeMs) {
 // src/init/schedule-core.ts
 var FORK_SOURCE = /* @__PURE__ */ Symbol("ScheduleCore.fork.source");
 function acknowledgesPersistence(action) {
-  return action.kind === "persistence-acknowledge" || action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true;
+  return action.kind === DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE || action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true;
 }
 function changesRequireFilterProjectionRebuild(changes) {
   for (const change of changes.activities) {
@@ -21291,6 +22024,30 @@ function isCurrentFilterProjection(projection, filter, context) {
   return hasCurrentHours && hasCurrentLocale;
 }
 var ScheduleCore = class _ScheduleCore {
+  /** Activity reads and mutations. */
+  activities;
+  /** Dependency-link reads and mutations. */
+  links;
+  /** Calendar reads and reconciliation. */
+  calendars;
+  /** Core-owned activity selection. */
+  selection;
+  /** Visibility, filtering, and order projection. */
+  view;
+  /** Baseline overlays and selection. */
+  baselines;
+  /** Pending impact-request synchronization. */
+  impactRequests;
+  /** External persistence tracking; no storage I/O is performed. */
+  persistence;
+  /** Undo and redo history. */
+  history;
+  /** Cross-instance projection change sets. */
+  projection;
+  /** Critical-path job lifecycle. */
+  criticalPath;
+  /** Effective-graph, revision, and digest diagnostics. */
+  diagnostics;
   _activityClipboard = { value: null };
   _status = SCHEDULE_CORE_STATUS.READY;
   coreRuntime;
@@ -21302,6 +22059,7 @@ var ScheduleCore = class _ScheduleCore {
   _criticalPathRevision = -1;
   _activeCriticalPath = null;
   constructor(input) {
+    Object.assign(this, createScheduleNamespaces(this));
     if (FORK_SOURCE in input) {
       this._isFork = true;
       const source = input[FORK_SOURCE];
@@ -21367,9 +22125,21 @@ var ScheduleCore = class _ScheduleCore {
     const waitForCriticalPathOnLoad = input.criticalPathOnLoad === true;
     this._ready = waitForCriticalPathOnLoad ? this._criticalPathReady.then(() => void 0) : this._initPromise;
   }
+  /**
+   * Resolves after initialization, and after initial critical path when
+   * `criticalPathOnLoad` is enabled.
+   */
   get ready() {
     return this._ready;
   }
+  /**
+   * Creates an isolated schedule with copied state, history, and generators.
+   *
+   * The fork runs the same mutation logic but disables dirty tracking:
+   * `persistence.hasChanges()` stays false and all dirty collections stay
+   * empty. It cannot acknowledge persistence and is never merged automatically.
+   * @returns A ready isolated schedule.
+   */
   fork() {
     return this._enqueue(async () => {
       await this._ready;
@@ -21379,19 +22149,48 @@ var ScheduleCore = class _ScheduleCore {
       });
     });
   }
+  /**
+   * Tracks the critical-path job current when this property is read.
+   *
+   * Later automatic work, including undo or redo recomputation, can replace
+   * the promise returned by subsequent reads. Use `whenSettled()` to wait for
+   * the current schedule revision.
+   * Apply a non-null `changes` value to the consumer-owned projection.
+   */
   get criticalPathReady() {
     return this._criticalPathReady;
   }
+  /**
+   * Current lifecycle health; `ready` can be observed before initialization
+   * finishes, so await {@link ScheduleCore.ready} before normal use.
+   */
   get status() {
     return this._status;
   }
+  /**
+   * Reads a defensive sector metadata snapshot without a readiness guard.
+   *
+   * @returns Cloned metadata, including values available after destruction.
+   */
   getSector() {
     return cloneDomainValue(this.coreRuntime.sector);
   }
+  /**
+   * Reads a defensive activity snapshot from a ready schedule.
+   *
+   * @param id - Canonical activity ID.
+   * @returns The activity, or `null` when absent.
+   */
   getActivityView(id) {
     this.assertReady();
     return readActivity(this.coreRuntime.state, id);
   }
+  /**
+   * Creates a read-only date prediction bound to the current revision.
+   *
+   * @param gesture - Move or resize gesture to preview.
+   * @returns A preview that throws after schedule state changes.
+   */
   createDateGesturePreview(gesture) {
     this.assertReady();
     const revision = this._scheduleRevision;
@@ -21402,10 +22201,16 @@ var ScheduleCore = class _ScheduleCore {
       }
     });
   }
+  /** @returns Defensive snapshots of every activity in the ready schedule. */
   getAllActivitiesView() {
     this.assertReady();
     return readAllActivities(this.coreRuntime.state);
   }
+  /**
+   * Computes the unique parent IDs allowed by the current indent plan.
+   *
+   * @param activityIds - Activities considered for indentation.
+   */
   getIndentTargetParentIds(activityIds) {
     this.assertReady();
     const plan = planIndentMoves(
@@ -21416,14 +22221,30 @@ var ScheduleCore = class _ScheduleCore {
       ...new Set(plan.allowedMoves.map((move) => String(move.newParentId)))
     ];
   }
+  /**
+   * Reads defensive direct-child snapshots in correlative order.
+   *
+   * @param parentId - Parent activity ID, or the root ID.
+   */
   getChildrenView(parentId) {
     this.assertReady();
     return readChildren(this.coreRuntime.state, parentId);
   }
+  /**
+   * Reads a defensive link snapshot.
+   *
+   * @param id - Canonical link ID.
+   * @returns The link, or `null` when absent. Stored lag is in working hours.
+   */
   getLinkView(id) {
     this.assertReady();
     return readLink(this.coreRuntime.state, id);
   }
+  /**
+   * Reads unique incoming and outgoing link snapshots for an activity.
+   *
+   * @param activityId - Activity whose links should be read.
+   */
   getLinksForActivityView(activityId) {
     this.assertReady();
     const state = this.coreRuntime.state;
@@ -21439,10 +22260,12 @@ var ScheduleCore = class _ScheduleCore {
     for (const linkId of state.getIncomingLinkIds(activityId)) append(linkId);
     return links;
   }
+  /** @returns Defensive snapshots of every link; stored lag is in working hours. */
   getAllLinksView() {
     this.assertReady();
     return readAllLinks(this.coreRuntime.state);
   }
+  /** @returns Counts and circular components from the effective dependency graph. */
   auditEffectiveGraph() {
     this.assertReady();
     const state = this.coreRuntime.state;
@@ -21463,58 +22286,90 @@ var ScheduleCore = class _ScheduleCore {
       largestComponentSize
     };
   }
+  /**
+   * Reads and clones one activity property.
+   *
+   * @param activityId - Canonical activity ID.
+   * @param property - Property to read.
+   * @returns The cloned value, or `null` when the activity is absent.
+   */
   getProperty(activityId, property) {
     this.assertReady();
     const snapshot = this.coreRuntime.state.getActivity(activityId);
     if (!snapshot) return null;
     return cloneDomainValue(snapshot[property]);
   }
+  /** @returns A read-only snapshot of all current activity IDs. */
   getAllIds() {
     this.assertReady();
     return readAllIds(this.coreRuntime.state);
   }
+  /**
+   * Visits each current activity ID without exposing mutable state.
+   *
+   * @param visit - Callback invoked once per current ID.
+   */
   forEachActivityId(visit) {
     this.assertReady();
     forEachActivityId(this.coreRuntime.state, visit);
   }
+  /**
+   * Reads direct child IDs in visual order.
+   *
+   * @param parentId - Parent activity ID, or the root ID.
+   */
   getChildrenIds(parentId) {
     this.assertReady();
     return readChildrenIds(this.coreRuntime.state, parentId);
   }
+  /** @returns A defensive snapshot of selected activity IDs. */
   getSelectedActivityIds() {
     this.assertReady();
     return readSelectedActivityIds(this.coreRuntime.state);
   }
+  /** @returns A defensive snapshot of explicitly hidden activity IDs. */
   getHiddenActivityIds() {
     this.assertReady();
     return this.coreRuntime.state.hiddenIds().map(String);
   }
+  /** @returns A defensive snapshot of activity IDs not currently hidden. */
   getVisibleActivityIds() {
     this.assertReady();
     const hiddenIds = new Set(this.coreRuntime.state.hiddenIds().map(String));
     return this.coreRuntime.state.getAllIds().map(String).filter((activityId) => !hiddenIds.has(activityId));
   }
+  /** @returns A defensive active-filter snapshot, or `null`. */
   getActiveFilter() {
     this.assertReady();
     return cloneDomainValue(this.coreRuntime.state.getActiveFilter());
   }
+  /** @returns A defensive active-order snapshot, or `null`. */
   getActiveOrder() {
     this.assertReady();
     return cloneDomainValue(this.coreRuntime.state.getActiveOrder());
   }
+  /** @returns Activity IDs in the current projected traversal order. */
   getVisualOrderIds() {
     this.assertReady();
     return [...this.coreRuntime.state.getVisualOrderIds()];
   }
+  /** @returns Whether the parent currently has a direct child. */
   hasChild(parentId) {
     this.assertReady();
     return readHasChild(this.coreRuntime.state, parentId);
   }
+  /**
+   * Reads a defensive schedule-calendar snapshot.
+   *
+   * @param id - Canonical calendar ID.
+   * @returns The calendar, or `null` when absent.
+   */
   getCalendar(id) {
     this.assertReady();
     const calendar = this.coreRuntime.calendars.get(id);
     return calendar ? cloneDomainValue(calendar) : null;
   }
+  /** @returns Defensive snapshots of every schedule calendar. */
   getAllCalendars() {
     this.assertReady();
     return Array.from(
@@ -21522,12 +22377,19 @@ var ScheduleCore = class _ScheduleCore {
       (calendar) => cloneDomainValue(calendar)
     );
   }
+  /** @returns Defensive snapshots of every base calendar. */
   getBaseCalendars() {
     this.assertReady();
     return this.coreRuntime.baseCalendars.map(
       (calendar) => cloneDomainValue(calendar)
     );
   }
+  /**
+   * Checks custom-ID uniqueness while optionally excluding the current value.
+   *
+   * @param customId - Candidate custom ID.
+   * @param currentCustomId - Existing value to ignore, or `null`.
+   */
   isCustomIdInUse(customId, currentCustomId = null) {
     this.assertReady();
     return this.coreRuntime.customIdTracker.isCustomIdInUse(
@@ -21535,24 +22397,29 @@ var ScheduleCore = class _ScheduleCore {
       currentCustomId
     );
   }
+  /** @returns The default calendar's earliest start/latest end, or `null`. */
   getProjectWorkHours() {
     this.assertReady();
     return computeProjectWorkHours(this.coreRuntime.calendars.values());
   }
+  /** @returns Defensive snapshots of modified persisted links; no I/O occurs. */
   getModifiedLinks() {
     this.assertReady();
     return this._saveTracker.modifiedLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
   }
+  /** @returns Defensive snapshots of not-yet-persisted links; no I/O occurs. */
   getNewLinks() {
     this.assertReady();
     return this._saveTracker.newLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
   }
+  /** @returns Defensive snapshots of modified persisted activities; no I/O occurs. */
   getModifiedActivities() {
     this.assertReady();
     return this._saveTracker.modifiedActivities(
       (activityId) => this.coreRuntime.state.getActivity(activityId)
     ).map(cloneDomainValue);
   }
+  /** @returns Modified persisted fields grouped by activity ID; no I/O occurs. */
   getModifiedActivityFields() {
     this.assertReady();
     return cloneDomainValue(
@@ -21561,23 +22428,28 @@ var ScheduleCore = class _ScheduleCore {
       )
     );
   }
+  /** @returns Defensive snapshots of not-yet-persisted activities; no I/O occurs. */
   getNewActivities() {
     this.assertReady();
     return this._saveTracker.newActivities(
       (activityId) => this.coreRuntime.state.getActivity(activityId)
     ).map(cloneDomainValue);
   }
+  /** @returns Whether tracked state differs from the acknowledged save baseline. */
   hasUnsavedChanges() {
     this.assertReady();
     return this._saveTracker.hasUnsavedChanges();
   }
+  /** @returns The monotonic scheduling revision without a readiness guard. */
   getScheduleRevision() {
     return this._scheduleRevision;
   }
+  /** @returns The undo-history boundary for an external save checkpoint. */
   capturePersistenceHistoryBoundary() {
     this.assertReady();
     return this._undo.capturePersistenceBoundary();
   }
+  /** @returns A deterministic serialization digest of canonical schedule state. */
   getCanonicalDigest() {
     this.assertReady();
     const byId = (left, right) => String(left.id).localeCompare(String(right.id));
@@ -21589,6 +22461,13 @@ var ScheduleCore = class _ScheduleCore {
       baseCalendars: [...this.getBaseCalendars()].sort(byId)
     });
   }
+  /**
+   * Produces changes that transform a projection of `source` into this schedule.
+   *
+   * Both schedules must be ready. Neither instance is mutated or merged.
+   * @param source - Schedule currently represented by the consumer projection.
+   * @returns A complete consumer projection change set.
+   */
   createProjectionChangeSetFrom(source) {
     this.assertReady();
     source.assertReady();
@@ -21602,12 +22481,14 @@ var ScheduleCore = class _ScheduleCore {
     });
     return createProjectionChangeSet(projectionOf(this), projectionOf(source));
   }
+  /** @returns Deleted persisted activity identities since the last save. */
   getDeletedActivitiesSinceLastSave() {
     this.assertReady();
     return this._saveTracker.deletedActivities(
       (activityId) => this.coreRuntime.state.getActivity(activityId)
     ).map(cloneDomainValue);
   }
+  /** @returns Deleted persisted link identities since the last save. */
   getDeletedLinksSinceLastSave() {
     this.assertReady();
     return this._saveTracker.deletedLinks((linkId) => this.coreRuntime.state.getLink(linkId)).map(cloneDomainValue);
@@ -21647,10 +22528,27 @@ var ScheduleCore = class _ScheduleCore {
       );
     });
   }
+  /**
+   * Serializes and applies one public command to core-owned state.
+   *
+   * @param action - Public command. Activity-batch commands use
+   * {@link ScheduleCore.applyActivityBatch} instead.
+   * @param options - Per-operation autoschedule and critical-path controls.
+   * @returns The complete dispatch result unchanged, including change sets,
+   * verdicts, effects, tracking events, and warnings when present.
+   */
   async dispatch(action, options = {}) {
     const admitted = this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
   }
+  /**
+   * Serializes and applies an activity creation batch.
+   *
+   * @param action - Append/replace batch using working-day link lags and
+   * activity-creation overrides. Dispatch converts lags to stored hours.
+   * @param options - Per-operation autoschedule and critical-path controls.
+   * @returns The complete dispatch result unchanged.
+   */
   async applyActivityBatch(action, options = {}) {
     const admitted = this._beginScheduleMutation(action);
     return this._enqueue(() => this._dispatchInner(action, options, admitted));
@@ -21749,7 +22647,7 @@ var ScheduleCore = class _ScheduleCore {
     }
     if (result.ok) {
       if (historyPolicy === "checkpoint-on-success") {
-        if (action.kind !== "persistence-acknowledge") {
+        if (action.kind !== DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE) {
           throw new Error(
             "checkpoint-on-success requires persistence acknowledge"
           );
@@ -21771,7 +22669,7 @@ var ScheduleCore = class _ScheduleCore {
           action.activities ?? [],
           action.links ?? []
         );
-      } else if (action.kind === "activity-lookahead-sync" && action.acknowledgePersistedLookahead === true) {
+      } else if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC && action.acknowledgePersistedLookahead === true) {
         this._saveTracker.acknowledgePersistedLookahead(
           result.changes.activities,
           (activityId) => this.coreRuntime.state.getActivity(activityId)
@@ -21798,6 +22696,12 @@ var ScheduleCore = class _ScheduleCore {
     }
     return { result: toPublicDispatchResult(result), changedState: false };
   }
+  /**
+   * Queues critical-path calculation for the current revision.
+   *
+   * @returns A complete projection update, or `null` when already current,
+   * destroyed, or superseded.
+   */
   recomputeCriticalPath() {
     const operation = this._enqueue(async () => ({
       job: this._startCriticalPathForCurrentRevision()
@@ -21805,9 +22709,11 @@ var ScheduleCore = class _ScheduleCore {
     this._criticalPathReady = operation;
     return operation;
   }
+  /** @returns Whether no mutation or calculation remains for the current revision. */
   isCriticalPathSettled() {
     return this._criticalPathRevision === this._scheduleRevision && this._pendingScheduleRevision === this._scheduleRevision && this._activeCriticalPath === null;
   }
+  /** Resolves after repeatedly recomputing until the current revision is settled. */
   async whenCriticalPathSettled() {
     while (!this.isCriticalPathSettled()) {
       await this.recomputeCriticalPath();
@@ -21815,7 +22721,7 @@ var ScheduleCore = class _ScheduleCore {
   }
   _withReappliedViewState(action, result) {
     if (!result.ok) return result;
-    if (action.kind === "visibility-set") {
+    if (action.kind === DISPATCH_ACTION_KIND.VISIBILITY_SET) {
       this.coreRuntime.state.setFilterProjection(null);
     }
     if (!reappliesViewState(action)) return result;
@@ -21974,7 +22880,7 @@ var ScheduleCore = class _ScheduleCore {
             );
           }
           changes = await assembleChangeSet(this.coreRuntime.state, {
-            source: { kind: "init" },
+            source: { kind: CHANGE_SET_SOURCE_KIND.INIT },
             beforeSnap: /* @__PURE__ */ new Map(),
             touchedIds: [],
             scheduledIds: [],
@@ -22000,6 +22906,13 @@ var ScheduleCore = class _ScheduleCore {
     void promise.then(clearIfActive, clearIfActive);
     return promise;
   }
+  /**
+   * Applies the latest inverse operation through the serialized queue.
+   *
+   * @param options - Optional depth guard and critical-path suppression.
+   * @returns The complete projection change set, or `null` when unavailable or
+   * when the expected depth does not match.
+   */
   undo(options = {}) {
     const admitted = this._admitScheduleMutation();
     let changedState = false;
@@ -22055,6 +22968,12 @@ var ScheduleCore = class _ScheduleCore {
       return this._reapplyViewState(changes) ?? changes;
     }
   }
+  /**
+   * Reapplies the latest undone operation through the serialized queue.
+   *
+   * @param options - Optional critical-path suppression.
+   * @returns The complete projection change set, or `null` when unavailable.
+   */
   redo(options = {}) {
     const admitted = this._admitScheduleMutation();
     let changedState = false;
@@ -22105,15 +23024,19 @@ var ScheduleCore = class _ScheduleCore {
     );
     return this._reapplyViewState(changes) ?? changes;
   }
+  /** @returns Whether an undo entry is available; readiness is not required. */
   canUndo() {
     return this._undo.canUndo();
   }
+  /** @returns Whether a redo entry is available; readiness is not required. */
   canRedo() {
     return this._undo.canRedo();
   }
+  /** Clears undo and redo history without changing schedule state. */
   clearHistory() {
     this._undo.clear();
   }
+  /** @returns Current undo depth; readiness is not required. */
   undoDepth() {
     return this._undo.undoDepth();
   }
@@ -22123,6 +23046,10 @@ var ScheduleCore = class _ScheduleCore {
       this.coreRuntime.state.getAllActivities()
     );
   }
+  /**
+   * Cancels active critical-path work, clears caches, and permanently destroys
+   * this instance. Guarded reads and operations throw afterward.
+   */
   destroy() {
     if (this._activeCriticalPath) {
       this._activeCriticalPath.cancellation.cancelled = true;
@@ -22175,6 +23102,13 @@ function toPublicDispatchResult(result) {
   return publicResult;
 }
 
+// src/api/create-schedule.ts
+async function createSchedule(input) {
+  const schedule = new ScheduleCore(input);
+  await schedule.ready;
+  return schedule;
+}
+
 // src/boundary/save/unsaved.ts
 var getUnsavedActivities = (activities = []) => (activities ?? []).filter((activity) => !activity.proplannerId);
 
@@ -22193,67 +23127,6 @@ var CONSTRAINT_TYPE_TO_LABEL = {
 // src/constants/workday.ts
 var DEFAULT_HOURS_PER_DAY = 8;
 
-// src/dispatch/action-kinds.ts
-var DISPATCH_ACTION_KIND = {
-  ACTIVITY_CLIPBOARD_CLEAR: "activity-clipboard-clear",
-  ACTIVITY_COPY: "activity-copy",
-  ACTIVITY_PASTE_COPIED: "activity-paste-copied",
-  PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
-  BASELINE_APPLY: "baseline-apply",
-  PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
-  STATUS_CRITERIA_SET: "status-criteria-set",
-  INLINE_EDIT: "inline-edit",
-  DATES_BATCH: "dates-batch",
-  BULK_EDIT: "bulk-edit",
-  LINK_CREATE: "link-create",
-  LINK_UPDATE: "link-update",
-  LINK_DELETE: "link-delete",
-  LINKS_BATCH: "links-batch",
-  ACTIVITY_CREATE: "activity-create",
-  ACTIVITY_DELETE: "activity-delete",
-  ACTIVITY_MOVE: "activity-move",
-  ACTIVITY_INDENT: "activity-indent",
-  ACTIVITY_OUTDENT: "activity-outdent",
-  ACTIVITY_SET_PROGRESS: "activity-set-progress",
-  SELECTION_TOGGLE: "selection-toggle",
-  SELECTION_REPLACE: "selection-replace",
-  VISIBILITY_SET: "visibility-set",
-  FILTER_SET: "filter-set",
-  SORT_SET: "sort-set",
-  SIR_SYNC: "sir-sync",
-  ACTIVITY_LOOKAHEAD_SYNC: "activity-lookahead-sync"
-};
-var KIND_CATALOG_COVERS_UNION = {
-  [DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_COPY]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED]: true,
-  [DISPATCH_ACTION_KIND.PERSISTENCE_ACKNOWLEDGE]: true,
-  [DISPATCH_ACTION_KIND.BASELINE_APPLY]: true,
-  [DISPATCH_ACTION_KIND.PONDERATOR_CRITERION_SET]: true,
-  [DISPATCH_ACTION_KIND.STATUS_CRITERIA_SET]: true,
-  [DISPATCH_ACTION_KIND.INLINE_EDIT]: true,
-  [DISPATCH_ACTION_KIND.DATES_BATCH]: true,
-  [DISPATCH_ACTION_KIND.BULK_EDIT]: true,
-  [DISPATCH_ACTION_KIND.LINK_CREATE]: true,
-  [DISPATCH_ACTION_KIND.LINK_UPDATE]: true,
-  [DISPATCH_ACTION_KIND.LINK_DELETE]: true,
-  [DISPATCH_ACTION_KIND.LINKS_BATCH]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_CREATE]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_DELETE]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_MOVE]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_INDENT]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_OUTDENT]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_SET_PROGRESS]: true,
-  [DISPATCH_ACTION_KIND.SELECTION_TOGGLE]: true,
-  [DISPATCH_ACTION_KIND.SELECTION_REPLACE]: true,
-  [DISPATCH_ACTION_KIND.VISIBILITY_SET]: true,
-  [DISPATCH_ACTION_KIND.FILTER_SET]: true,
-  [DISPATCH_ACTION_KIND.SORT_SET]: true,
-  [DISPATCH_ACTION_KIND.SIR_SYNC]: true,
-  [DISPATCH_ACTION_KIND.ACTIVITY_LOOKAHEAD_SYNC]: true
-};
-var DISPATCH_ACTION_KINDS = Object.keys(KIND_CATALOG_COVERS_UNION);
-
 // src/creation/creation-kinds.ts
 var CREATION_KIND = {
   CHILD: "child",
@@ -22262,28 +23135,52 @@ var CREATION_KIND = {
   ROOT: "root"
 };
 
+exports.ACTIVITY_BATCH_ACTION_KIND = ACTIVITY_BATCH_ACTION_KIND;
+exports.ACTIVITY_BATCH_MODE = ACTIVITY_BATCH_MODE;
+exports.ACTIVITY_DATE_EDGE = ACTIVITY_DATE_EDGE;
+exports.ACTIVITY_FIELD = ACTIVITY_FIELD;
+exports.ACTIVITY_PONDERATOR_CRITERION = ACTIVITY_PONDERATOR_CRITERION;
 exports.ACTIVITY_TYPE = ACTIVITY_TYPE;
 exports.CALENDAR_UNIT = CALENDAR_UNIT;
+exports.CHANGE_SET_SOURCE_KIND = CHANGE_SET_SOURCE_KIND;
 exports.COLUMN = COLUMN;
+exports.COMPLETED_PROGRESS = COMPLETED_PROGRESS;
 exports.CONSTRAINT_TYPE = CONSTRAINT_TYPE;
 exports.CONSTRAINT_TYPE_TO_LABEL = CONSTRAINT_TYPE_TO_LABEL;
+exports.CONSTRAINT_WARNING_KIND = CONSTRAINT_WARNING_KIND;
 exports.CREATION_KIND = CREATION_KIND;
+exports.DATE_GESTURE_KIND = DATE_GESTURE_KIND;
 exports.DEFAULT_HOURS_PER_DAY = DEFAULT_HOURS_PER_DAY;
 exports.DISPATCH_ACTION_KIND = DISPATCH_ACTION_KIND;
 exports.DISPATCH_ACTION_KINDS = DISPATCH_ACTION_KINDS;
+exports.DISPATCH_LINK_OPERATION_KIND = DISPATCH_LINK_OPERATION_KIND;
 exports.DISPATCH_TRACK_EVENT = DISPATCH_TRACK_EVENT;
+exports.FILTER_FIELD = FILTER_FIELD;
+exports.FILTER_LOGIC = FILTER_LOGIC;
+exports.FILTER_OPERATOR = FILTER_OPERATOR;
+exports.FILTER_REJECTION_REASON = FILTER_REJECTION_REASON;
+exports.FILTER_VALUE_KIND = FILTER_VALUE_KIND;
+exports.LINK_BATCH_OPERATION_KIND = LINK_BATCH_OPERATION_KIND;
 exports.LINK_CODE_TO_TYPE = LINK_CODE_TO_TYPE;
+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.NEW_ACTIVITY_DEFAULTS = NEW_ACTIVITY_DEFAULTS;
+exports.NOT_STARTED_PROGRESS = NOT_STARTED_PROGRESS;
+exports.ORDER_DIRECTION = ORDER_DIRECTION;
 exports.REJECTION_REASON = REJECTION_REASON;
 exports.ROOT_PARENT_ID = ROOT_PARENT_ID;
 exports.SCHEDULE_CORE_STATUS = SCHEDULE_CORE_STATUS;
+exports.SCHEDULE_EFFECT_KIND = SCHEDULE_EFFECT_KIND;
+exports.SIR_AUTO_REJECT_REASON = SIR_AUTO_REJECT_REASON;
 exports.STATUS = STATUS;
+exports.STATUS_CRITERIA = STATUS_CRITERIA;
 exports.ScheduleCore = ScheduleCore;
 exports.WORK_TIME_DIRECTION = WORK_TIME_DIRECTION;
 exports.checkNoUpdatedLinks = checkNoUpdatedLinks;
 exports.computeExpectedProgress = computeExpectedProgress;
+exports.createSchedule = createSchedule;
 exports.expectedProgressFromBaseline = expectedProgressFromBaseline;
 exports.getActiveBaseline = getActiveBaseline;
 exports.getUnsavedActivities = getUnsavedActivities;