@outbuild-company/schedule-core 1.6.0 → 1.6.2

package/dist/index.d.cts

@@ -322,6 +322,32 @@ interface PersistedEntityIdentity {
     readonly id: string;
     readonly proplannerId: number;
 }
+type ActivityBatchMode = 'append' | 'replace';
+type ActivityBatchReference = ActivityId | {
+    readonly batchId: string;
+};
+type ActivityBatchParentReference = '0' | ActivityBatchReference;
+interface ActivityBatchItem {
+    readonly batchId: string;
+    readonly parent: ActivityBatchParentReference;
+    readonly index?: number;
+    readonly activityId?: ActivityId;
+    readonly overrides?: CreationOverrides;
+}
+interface ActivityBatchLinkInput {
+    readonly source: ActivityBatchReference;
+    readonly target: ActivityBatchReference;
+    readonly type: LinkType;
+    readonly lag: number;
+    readonly linkId?: LinkId;
+}
+interface ActivityBatchAction {
+    readonly kind: 'activity-batch';
+    readonly mode: ActivityBatchMode;
+    readonly items: ReadonlyArray<ActivityBatchItem>;
+    readonly links: ReadonlyArray<ActivityBatchLinkInput>;
+    readonly eventSource?: string;
+}
 
 type DispatchAction = {
     kind: 'persistence-acknowledge';
@@ -441,6 +467,7 @@ type DispatchAction = {
     activityIds: ReadonlyArray<ActivityId>;
     isLookahead: boolean;
     hasLookaheadTasks: boolean;
+    acknowledgePersistedLookahead?: boolean;
     eventSource?: string;
 } | {
     kind: 'activity-paste';
@@ -455,6 +482,7 @@ type DispatchAction = {
     links: ReadonlyArray<PastedLinkInput>;
     eventSource?: string;
 };
+type InternalDispatchAction = DispatchAction | ActivityBatchAction;
 interface PastedActivityInput {
     readonly originalId: ActivityId;
     readonly originalParentId: ActivityId | '0';
@@ -534,7 +562,7 @@ interface ViewStateChange {
     readonly visible?: ViewStatePropChange;
 }
 interface ChangeSet {
-    source: DispatchAction | {
+    source: InternalDispatchAction | {
         kind: 'init';
     } | {
         kind: 'undo';
@@ -693,12 +721,56 @@ interface ScheduleCoreInput extends BackendScheduleInput {
     reporter?: ScheduleCoreReporter;
 }
 
+type DateGesture = {
+    readonly kind: 'move';
+    readonly activityIds: readonly ActivityId[];
+    readonly anchorActivityId: ActivityId;
+} | {
+    readonly kind: 'resize-start' | 'resize-end';
+    readonly activityId: ActivityId;
+};
+interface DateGesturePreview {
+    getDates(activityId: ActivityId, proposedEdgeTimeMs: number): {
+        startTimeMs: number;
+        endTimeMs: number;
+    } | null;
+}
+
+interface UndoOptions {
+    readonly skipCriticalPath?: boolean;
+    readonly expectedUndoDepth?: number;
+}
+
 declare class ScheduleCore {
     private _status;
     private readonly coreRuntime;
     private readonly _undo;
     private _opQueue;
     private _scheduleRevision;
+    /**
+     * Revision counting mutations that have been ADMITTED, whether or not they
+     * have changed anything yet. `_scheduleRevision` counts the ones that
+     * actually did.
+     *
+     * INVARIANT: `_pendingScheduleRevision >= _scheduleRevision`, and equality
+     * means no mutation is in flight.
+     *
+     * The two exist separately because the useful instant and the knowable
+     * instant are not the same one. A critical-path calculation becomes garbage
+     * the moment the next mutation is admitted, but whether that mutation is
+     * substantive is only knowable once its ChangeSet exists, which is hundreds
+     * of milliseconds later at project scale. Measured live on a 12268-activity
+     * project: the cancellation flag flipped 929 ms into a 930 ms calculation,
+     * 812 into 812 and 785 into 785, because the job's apply block queues behind
+     * the very dispatch whose completion cancels it. Cancellation and job end
+     * were the same event, so every discarded job ran the whole calculation.
+     *
+     * Splitting the counter buys the early signal without moving the meaning of
+     * `_scheduleRevision`, whose three readers (`isCriticalPathSettled`,
+     * `createDateGesturePreview` and the job's own `isCurrent`) are all written
+     * against "the state actually changed".
+     */
+    private _pendingScheduleRevision;
     private _criticalPathRevision;
     private _activeCriticalPath;
     constructor(input: ScheduleCoreInput);
@@ -709,6 +781,7 @@ declare class ScheduleCore {
     get status(): ScheduleCoreStatus;
     getSector(): Readonly<SectorMetadata>;
     getActivityView(id: ActivityId): Readonly<CoreActivity> | null;
+    createDateGesturePreview(gesture: DateGesture): DateGesturePreview;
     getAllActivitiesView(): ReadonlyArray<Readonly<CoreActivity>>;
     getChildrenView(parentId: ActivityId | '0'): ReadonlyArray<Readonly<CoreActivity>>;
     getLinkView(id: LinkId): Readonly<Link> | null;
@@ -734,8 +807,51 @@ declare class ScheduleCore {
     getDeletedActivitiesSinceLastSave(): ReadonlyArray<Readonly<DeletedActivitySnapshot>>;
     getDeletedLinksSinceLastSave(): ReadonlyArray<Readonly<DeletedLinkSnapshot>>;
     private _enqueue;
+    /**
+     * Marks a mutation as admitted and invalidates the calculation in flight.
+     *
+     * Called BEFORE `_enqueue`, which is the point of the whole thing: the wait
+     * in the operation queue is part of the window a running calculation wastes,
+     * and it is the longest part of it when several mutations are already
+     * queued.
+     *
+     * `dispatchChangesSchedulingState` is a pure function of the action, so this
+     * decision needs no state and cannot be wrong about the action's nature. What
+     * it cannot know yet is whether the mutation will produce anything, which is
+     * what `_settleScheduleMutation` reconciles afterwards.
+     */
+    private _beginScheduleMutation;
+    /** Undo and redo have no action to classify: reaching them IS the mutation. */
+    private _admitScheduleMutation;
+    /**
+     * Closes a mutation admitted by `_beginScheduleMutation`, on EVERY exit path.
+     *
+     * `changedState` false means the mutation was admitted and produced nothing
+     * (rejected, non-substantive, or rolled back). The pending revision walks
+     * back so the invariant holds and `isCriticalPathSettled` keeps telling the
+     * truth, and the calculation this mutation killed for nothing is re-armed.
+     *
+     * The re-arm goes through the queue and that is not incidental. Started
+     * outside it, the calculation would run immediately while the next queued
+     * mutation is still waiting, and that mutation would kill it again on
+     * admission: a cancel-and-restart treadmill burning a fresh project-wide deep
+     * copy per lap. Inside the queue the restart cannot happen until the queue
+     * drains, so at most one calculation is armed per settled mutation. The burst
+     * scenario will NOT catch a regression here, because there every dispatch
+     * succeeds and this path is never taken.
+     *
+     * It re-arms through `recomputeCriticalPath` rather than enqueueing the job
+     * directly, because the queue slot must NOT await the job: the job's own
+     * apply block needs a later slot on this same queue, so awaiting it from
+     * inside a slot deadlocks the core. `recomputeCriticalPath` already has the
+     * shape that returns the job's promise out of the slot instead of awaiting
+     * it, and it keeps `_criticalPathReady` pointing at the live calculation.
+     */
+    private _settleScheduleMutation;
     dispatch(action: DispatchAction, options?: DispatchOptions): Promise<DispatchResult>;
+    applyActivityBatch(action: ActivityBatchAction, options?: DispatchOptions): Promise<DispatchResult>;
     private _dispatchInner;
+    private _runDispatch;
     recomputeCriticalPath(): Promise<{
         changes: ChangeSet;
     } | null>;
@@ -791,13 +907,12 @@ declare class ScheduleCore {
     private _recordScheduleMutation;
     private _startCriticalPathForCurrentRevision;
     private _runCriticalPathAndCapture;
-    private _recomputeAfterHistoryRestore;
-    undo(options?: {
-        skipCriticalPath?: boolean;
-    }): Promise<ChangeSet | null>;
+    undo(options?: UndoOptions): Promise<ChangeSet | null>;
+    private _runUndo;
     redo(options?: {
         skipCriticalPath?: boolean;
     }): Promise<ChangeSet | null>;
+    private _runRedo;
     canUndo(): boolean;
     canRedo(): boolean;
     clearHistory(): void;
@@ -955,4 +1070,4 @@ declare const DISPATCH_TRACK_EVENT: {
 };
 type DispatchTrackEvent = (typeof DISPATCH_TRACK_EVENT)[keyof typeof DISPATCH_TRACK_EVENT];
 
-export { ACTIVITY_TYPE, type ActivityCreter, type ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, type FilterCriterion, type FilterDateRange, type FilterField, type FilterState, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OrderRule, type OrderState, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, type PersistedEntityIdentity, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, WORK_TIME_DIRECTION, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };
+export { ACTIVITY_TYPE, type ActivityBatchAction, type ActivityBatchItem, type ActivityBatchLinkInput, type ActivityBatchMode, type ActivityBatchParentReference, type ActivityBatchReference, type ActivityCreter, type ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DateGesture, type DateGesturePreview, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, type FilterCriterion, type FilterDateRange, type FilterField, type FilterState, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OrderRule, type OrderState, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, type PersistedEntityIdentity, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, type UndoOptions, WORK_TIME_DIRECTION, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };

package/dist/index.d.ts

@@ -322,6 +322,32 @@ interface PersistedEntityIdentity {
     readonly id: string;
     readonly proplannerId: number;
 }
+type ActivityBatchMode = 'append' | 'replace';
+type ActivityBatchReference = ActivityId | {
+    readonly batchId: string;
+};
+type ActivityBatchParentReference = '0' | ActivityBatchReference;
+interface ActivityBatchItem {
+    readonly batchId: string;
+    readonly parent: ActivityBatchParentReference;
+    readonly index?: number;
+    readonly activityId?: ActivityId;
+    readonly overrides?: CreationOverrides;
+}
+interface ActivityBatchLinkInput {
+    readonly source: ActivityBatchReference;
+    readonly target: ActivityBatchReference;
+    readonly type: LinkType;
+    readonly lag: number;
+    readonly linkId?: LinkId;
+}
+interface ActivityBatchAction {
+    readonly kind: 'activity-batch';
+    readonly mode: ActivityBatchMode;
+    readonly items: ReadonlyArray<ActivityBatchItem>;
+    readonly links: ReadonlyArray<ActivityBatchLinkInput>;
+    readonly eventSource?: string;
+}
 
 type DispatchAction = {
     kind: 'persistence-acknowledge';
@@ -441,6 +467,7 @@ type DispatchAction = {
     activityIds: ReadonlyArray<ActivityId>;
     isLookahead: boolean;
     hasLookaheadTasks: boolean;
+    acknowledgePersistedLookahead?: boolean;
     eventSource?: string;
 } | {
     kind: 'activity-paste';
@@ -455,6 +482,7 @@ type DispatchAction = {
     links: ReadonlyArray<PastedLinkInput>;
     eventSource?: string;
 };
+type InternalDispatchAction = DispatchAction | ActivityBatchAction;
 interface PastedActivityInput {
     readonly originalId: ActivityId;
     readonly originalParentId: ActivityId | '0';
@@ -534,7 +562,7 @@ interface ViewStateChange {
     readonly visible?: ViewStatePropChange;
 }
 interface ChangeSet {
-    source: DispatchAction | {
+    source: InternalDispatchAction | {
         kind: 'init';
     } | {
         kind: 'undo';
@@ -693,12 +721,56 @@ interface ScheduleCoreInput extends BackendScheduleInput {
     reporter?: ScheduleCoreReporter;
 }
 
+type DateGesture = {
+    readonly kind: 'move';
+    readonly activityIds: readonly ActivityId[];
+    readonly anchorActivityId: ActivityId;
+} | {
+    readonly kind: 'resize-start' | 'resize-end';
+    readonly activityId: ActivityId;
+};
+interface DateGesturePreview {
+    getDates(activityId: ActivityId, proposedEdgeTimeMs: number): {
+        startTimeMs: number;
+        endTimeMs: number;
+    } | null;
+}
+
+interface UndoOptions {
+    readonly skipCriticalPath?: boolean;
+    readonly expectedUndoDepth?: number;
+}
+
 declare class ScheduleCore {
     private _status;
     private readonly coreRuntime;
     private readonly _undo;
     private _opQueue;
     private _scheduleRevision;
+    /**
+     * Revision counting mutations that have been ADMITTED, whether or not they
+     * have changed anything yet. `_scheduleRevision` counts the ones that
+     * actually did.
+     *
+     * INVARIANT: `_pendingScheduleRevision >= _scheduleRevision`, and equality
+     * means no mutation is in flight.
+     *
+     * The two exist separately because the useful instant and the knowable
+     * instant are not the same one. A critical-path calculation becomes garbage
+     * the moment the next mutation is admitted, but whether that mutation is
+     * substantive is only knowable once its ChangeSet exists, which is hundreds
+     * of milliseconds later at project scale. Measured live on a 12268-activity
+     * project: the cancellation flag flipped 929 ms into a 930 ms calculation,
+     * 812 into 812 and 785 into 785, because the job's apply block queues behind
+     * the very dispatch whose completion cancels it. Cancellation and job end
+     * were the same event, so every discarded job ran the whole calculation.
+     *
+     * Splitting the counter buys the early signal without moving the meaning of
+     * `_scheduleRevision`, whose three readers (`isCriticalPathSettled`,
+     * `createDateGesturePreview` and the job's own `isCurrent`) are all written
+     * against "the state actually changed".
+     */
+    private _pendingScheduleRevision;
     private _criticalPathRevision;
     private _activeCriticalPath;
     constructor(input: ScheduleCoreInput);
@@ -709,6 +781,7 @@ declare class ScheduleCore {
     get status(): ScheduleCoreStatus;
     getSector(): Readonly<SectorMetadata>;
     getActivityView(id: ActivityId): Readonly<CoreActivity> | null;
+    createDateGesturePreview(gesture: DateGesture): DateGesturePreview;
     getAllActivitiesView(): ReadonlyArray<Readonly<CoreActivity>>;
     getChildrenView(parentId: ActivityId | '0'): ReadonlyArray<Readonly<CoreActivity>>;
     getLinkView(id: LinkId): Readonly<Link> | null;
@@ -734,8 +807,51 @@ declare class ScheduleCore {
     getDeletedActivitiesSinceLastSave(): ReadonlyArray<Readonly<DeletedActivitySnapshot>>;
     getDeletedLinksSinceLastSave(): ReadonlyArray<Readonly<DeletedLinkSnapshot>>;
     private _enqueue;
+    /**
+     * Marks a mutation as admitted and invalidates the calculation in flight.
+     *
+     * Called BEFORE `_enqueue`, which is the point of the whole thing: the wait
+     * in the operation queue is part of the window a running calculation wastes,
+     * and it is the longest part of it when several mutations are already
+     * queued.
+     *
+     * `dispatchChangesSchedulingState` is a pure function of the action, so this
+     * decision needs no state and cannot be wrong about the action's nature. What
+     * it cannot know yet is whether the mutation will produce anything, which is
+     * what `_settleScheduleMutation` reconciles afterwards.
+     */
+    private _beginScheduleMutation;
+    /** Undo and redo have no action to classify: reaching them IS the mutation. */
+    private _admitScheduleMutation;
+    /**
+     * Closes a mutation admitted by `_beginScheduleMutation`, on EVERY exit path.
+     *
+     * `changedState` false means the mutation was admitted and produced nothing
+     * (rejected, non-substantive, or rolled back). The pending revision walks
+     * back so the invariant holds and `isCriticalPathSettled` keeps telling the
+     * truth, and the calculation this mutation killed for nothing is re-armed.
+     *
+     * The re-arm goes through the queue and that is not incidental. Started
+     * outside it, the calculation would run immediately while the next queued
+     * mutation is still waiting, and that mutation would kill it again on
+     * admission: a cancel-and-restart treadmill burning a fresh project-wide deep
+     * copy per lap. Inside the queue the restart cannot happen until the queue
+     * drains, so at most one calculation is armed per settled mutation. The burst
+     * scenario will NOT catch a regression here, because there every dispatch
+     * succeeds and this path is never taken.
+     *
+     * It re-arms through `recomputeCriticalPath` rather than enqueueing the job
+     * directly, because the queue slot must NOT await the job: the job's own
+     * apply block needs a later slot on this same queue, so awaiting it from
+     * inside a slot deadlocks the core. `recomputeCriticalPath` already has the
+     * shape that returns the job's promise out of the slot instead of awaiting
+     * it, and it keeps `_criticalPathReady` pointing at the live calculation.
+     */
+    private _settleScheduleMutation;
     dispatch(action: DispatchAction, options?: DispatchOptions): Promise<DispatchResult>;
+    applyActivityBatch(action: ActivityBatchAction, options?: DispatchOptions): Promise<DispatchResult>;
     private _dispatchInner;
+    private _runDispatch;
     recomputeCriticalPath(): Promise<{
         changes: ChangeSet;
     } | null>;
@@ -791,13 +907,12 @@ declare class ScheduleCore {
     private _recordScheduleMutation;
     private _startCriticalPathForCurrentRevision;
     private _runCriticalPathAndCapture;
-    private _recomputeAfterHistoryRestore;
-    undo(options?: {
-        skipCriticalPath?: boolean;
-    }): Promise<ChangeSet | null>;
+    undo(options?: UndoOptions): Promise<ChangeSet | null>;
+    private _runUndo;
     redo(options?: {
         skipCriticalPath?: boolean;
     }): Promise<ChangeSet | null>;
+    private _runRedo;
     canUndo(): boolean;
     canRedo(): boolean;
     clearHistory(): void;
@@ -955,4 +1070,4 @@ declare const DISPATCH_TRACK_EVENT: {
 };
 type DispatchTrackEvent = (typeof DISPATCH_TRACK_EVENT)[keyof typeof DISPATCH_TRACK_EVENT];
 
-export { ACTIVITY_TYPE, type ActivityCreter, type ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, type FilterCriterion, type FilterDateRange, type FilterField, type FilterState, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OrderRule, type OrderState, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, type PersistedEntityIdentity, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, WORK_TIME_DIRECTION, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };
+export { ACTIVITY_TYPE, type ActivityBatchAction, type ActivityBatchItem, type ActivityBatchLinkInput, type ActivityBatchMode, type ActivityBatchParentReference, type ActivityBatchReference, type ActivityCreter, type ActivityId, type ActivityType, type BackendActivityInput, type BackendCalendarInput, type BackendLinkInput, type BackendScheduleInput, type BackendSectorInput, type BaselinePoint, type BaselineVersion, type BranchOrderChange, CALENDAR_UNIT, COLUMN, CONSTRAINT_TYPE, CONSTRAINT_TYPE_TO_LABEL, CREATION_KIND, type Calendar, type CalendarId, type CalendarUnit, type CalendarWorktime, type ChangeSet, type ColumnName, type ConstraintType, type ConstraintWarning, type CoreActivity, type CreationKind, DEFAULT_HOURS_PER_DAY, DISPATCH_ACTION_KIND, DISPATCH_ACTION_KINDS, DISPATCH_TRACK_EVENT, type DateGesture, type DateGesturePreview, type DeletedActivitySnapshot, type DeletedLinkSnapshot, type DispatchAction, type DispatchActionKind, type DispatchOptions, type DispatchRejectReason, type DispatchResult, type DispatchTrackEvent, type EntityChange, type FilterCriterion, type FilterDateRange, type FilterField, type FilterState, LINK_CODE_TO_TYPE, LINK_TYPE, LINK_TYPE_CODE, type Link, type LinkId, type LinkType, type LinkTypeCode, type LinksBatchOperation, NEW_ACTIVITY_DEFAULTS, type OrderRule, type OrderState, type ParsedInput, type PastedActivityInput, type PastedLinkInput, type PendingRequest, type PersistedEntityIdentity, REJECTION_REASON, ROOT_PARENT_ID, ScheduleCore, type ScheduleCoreInput, type ScheduleCoreReporter, type ScheduleCoreStatus, type ScheduleEffect, type SectorMetadata, type StatusCriteria, type TrackingEvent, type UndoOptions, WORK_TIME_DIRECTION, type WorkTimeDirection, checkNoUpdatedLinks, computeExpectedProgress, expectedProgressFromBaseline, getActiveBaseline, getUnsavedActivities, isRootParent, normalizeParentKey, parseFromBackend, willRunCriticalPath, yieldToBrowser };