@rushstack/rush-sdk 5.96.0 → 5.97.1-pr3481.18

package/lib/cli/parsing/SelectionParameterSet.d.ts

@@ -20,7 +20,15 @@ export declare class SelectionParameterSet {
     private readonly _fromVersionPolicy;
     private readonly _toVersionPolicy;
     private readonly _selectorParserByScope;
+    private readonly _selectors;
+    private _isSelectionSpecified;
     constructor(rushConfiguration: RushConfiguration, action: CommandLineParameterProvider, gitOptions: IGitSelectorParserOptions);
+    /**
+     * Check if any of the selection parameters have a value specified on the command line
+     *
+     * Returns true if specifying any selection parameters, otherwise false.
+     */
+    get isSelectionSpecified(): boolean;
     /**
      * Computes the set of selected projects based on all parameter values.
      *
@@ -28,14 +36,19 @@ export declare class SelectionParameterSet {
      */
     getSelectedProjectsAsync(terminal: ITerminal): Promise<Set<RushConfigurationProject>>;
     /**
-     * Represents the selection as `--filter` parameters to pnpm.
+     * Represents the selection as `--filter` parameters to pnpm, and selected projects when partial install
      *
      * @remarks
      * This is a separate from the selection to allow the filters to be represented more concisely.
      *
-     * @see https://pnpm.js.org/en/filtering
+     * @see https://pnpm.io/filtering
      */
-    getPnpmFilterArgumentsAsync(terminal: ITerminal): Promise<string[]>;
+    getPnpmFilterArgumentsAsync(terminal: ITerminal): Promise<{
+        pnpmFilterArguments: string[];
+        splitWorkspacePnpmFilterArguments: string[];
+        selectedProjects: Set<RushConfigurationProject> | undefined;
+        hasSelectSplitWorkspaceProject: boolean;
+    }>;
     /**
      * Usage telemetry for selection parameters. Only saved locally, and if requested in the config.
      */
@@ -47,5 +60,6 @@ export declare class SelectionParameterSet {
      * Handles '.', unscoped names, and scoped names.
      */
     private _evaluateProjectParameterAsync;
+    toArguments(): string[];
 }
 //# sourceMappingURL=SelectionParameterSet.d.ts.map

package/lib/index.d.ts

@@ -9,6 +9,7 @@ export { INpmOptionsJson as _INpmOptionsJson, NpmOptionsConfiguration } from './
 export { IYarnOptionsJson as _IYarnOptionsJson, YarnOptionsConfiguration } from './logic/yarn/YarnOptionsConfiguration';
 export { IPnpmOptionsJson as _IPnpmOptionsJson, PnpmStoreOptions, PnpmOptionsConfiguration } from './logic/pnpm/PnpmOptionsConfiguration';
 export { BuildCacheConfiguration } from './api/BuildCacheConfiguration';
+export { CobuildConfiguration, ICobuildJson } from './api/CobuildConfiguration';
 export { GetCacheEntryIdFunction, IGenerateCacheEntryIdOptions } from './logic/buildCache/CacheEntryId';
 export { FileSystemBuildCacheProvider, IFileSystemBuildCacheProviderOptions } from './logic/buildCache/FileSystemBuildCacheProvider';
 export { IPhase } from './api/CommandLineConfiguration';
@@ -25,7 +26,8 @@ export { RepoStateFile } from './logic/RepoStateFile';
 export { LookupByPath, IPrefixMatch } from './logic/LookupByPath';
 export { EventHooks, Event } from './api/EventHooks';
 export { ChangeManager } from './api/ChangeManager';
-export { LastInstallFlag as _LastInstallFlag, ILockfileValidityCheckOptions as _ILockfileValidityCheckOptions } from './api/LastInstallFlag';
+export { LastInstallFlag as _LastInstallFlag, ILastInstallFlagJson as _ILastInstallFlagJson, ILockfileValidityCheckOptions as _ILockfileValidityCheckOptions } from './api/LastInstallFlag';
+export { BaseFlag as _BaseFlag } from './api/base/BaseFlag';
 export { VersionPolicyDefinitionName, BumpType, LockStepVersionPolicy, IndividualVersionPolicy, VersionPolicy } from './api/VersionPolicy';
 export { VersionPolicyConfiguration } from './api/VersionPolicyConfiguration';
 export { ILaunchOptions, Rush } from './api/Rush';
@@ -36,7 +38,7 @@ export { IOperationRunner, IOperationRunnerContext } from './logic/operations/IO
 export { IExecutionResult, IOperationExecutionResult } from './logic/operations/IOperationExecutionResult';
 export { IOperationOptions, Operation } from './logic/operations/Operation';
 export { OperationStatus } from './logic/operations/OperationStatus';
-export { RushSession, IRushSessionOptions, CloudBuildCacheProviderFactory } from './pluginFramework/RushSession';
+export { RushSession, IRushSessionOptions, CloudBuildCacheProviderFactory, CobuildLockProviderFactory } from './pluginFramework/RushSession';
 export { IRushCommand, IGlobalCommand, IPhasedCommand, RushLifecycleHooks } from './pluginFramework/RushLifeCycle';
 export { ICreateOperationsContext, PhasedCommandHooks } from './pluginFramework/PhasedCommandHooks';
 export { IRushPlugin } from './pluginFramework/IRushPlugin';
@@ -44,6 +46,7 @@ export { IBuiltInPluginConfiguration as _IBuiltInPluginConfiguration } from './p
 export { IRushPluginConfigurationBase as _IRushPluginConfigurationBase } from './api/RushPluginsConfiguration';
 export { ILogger } from './pluginFramework/logging/Logger';
 export { ICloudBuildCacheProvider } from './logic/buildCache/ICloudBuildCacheProvider';
+export { ICobuildLockProvider, ICobuildContext, ICobuildCompletedState } from './logic/cobuild/ICobuildLockProvider';
 export { ICredentialCacheOptions, ICredentialCacheEntry, CredentialCache } from './logic/CredentialCache';
 export type { ITelemetryData, ITelemetryMachineInfo, ITelemetryOperationResult } from './logic/Telemetry';
 export { IStopwatchResult } from './utilities/Stopwatch';

package/lib/logic/PurgeManager.d.ts

@@ -9,6 +9,7 @@ export declare class PurgeManager {
     private _rushGlobalFolder;
     private _rushUserFolderRecycler;
     readonly commonTempFolderRecycler: AsyncRecycler;
+    readonly commonTempSplitFolderRecycler: AsyncRecycler;
     constructor(rushConfiguration: RushConfiguration, rushGlobalFolder: RushGlobalFolder);
     /**
      * Performs the AsyncRecycler.deleteAll() operation.  This should be called before

package/lib/logic/RushConstants.d.ts

@@ -43,6 +43,12 @@ export declare class RushConstants {
      * Example: `C:\MyRepo\common\temp`
      */
     static readonly rushTempFolderName: string;
+    /**
+     * The folder name ("temp-split") under the common folder, or under the .rush folder in each project's directory where
+     * temporary files will be stored.
+     * Example: `C:\MyRepo\common\temp-split`
+     */
+    static readonly rushTempSplitFolderName: string;
     /**
      * The folder name ("projects") where temporary projects will be stored.
      * Example: `C:\MyRepo\common\temp\projects`
@@ -148,6 +154,15 @@ export declare class RushConstants {
      * Changing this ensures that cache entries generated by an old version will no longer register as a cache hit.
      */
     static readonly buildCacheVersion: number;
+    /**
+     * Cobuild configuration file.
+     */
+    static readonly cobuildFilename: string;
+    /**
+     * Cobuild version number, incremented when the logic to create cobuild lock changes.
+     * Changing this ensures that lock generated by an old version will no longer access as a cobuild lock.
+     */
+    static readonly cobuildLockVersion: number;
     /**
      * Per-project configuration filename.
      */

package/lib/logic/base/BaseInstallManagerTypes.d.ts

@@ -1,3 +1,5 @@
+import type { SelectionParameterSet } from '../../cli/parsing/SelectionParameterSet';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 export interface IInstallManagerOptions {
     /**
      * Whether the global "--debug" flag was specified.
@@ -61,5 +63,26 @@ export interface IInstallManagerOptions {
      * Callback to invoke between preparing the common/temp folder and running installation.
      */
     beforeInstallAsync?: () => Promise<void>;
+    /**
+     * Whether to specify "--ignore-scripts" command-line parameter, which ignores
+     * install lifecycle scripts in package.json and its dependencies
+     */
+    ignoreScripts: boolean;
+    /**
+     * Whether to install for projects in split workspace
+     */
+    includeSplitWorkspace: boolean;
+    /**
+     * Filters to be passed to PNPM during installation for split workspace.
+     */
+    splitWorkspacePnpmFilterArguments: string[];
+    /**
+     * Selected projects during partial install.
+     */
+    selectedProjects?: Set<RushConfigurationProject>;
+    /**
+     * Selection parameters for partial install.
+     */
+    selectionParameters?: SelectionParameterSet;
 }
 //# sourceMappingURL=BaseInstallManagerTypes.d.ts.map

package/lib/logic/buildCache/ProjectBuildCache.d.ts

@@ -1,10 +1,10 @@
 import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
-import { RushProjectConfiguration } from '../../api/RushProjectConfiguration';
 import { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 export interface IProjectBuildCacheOptions {
     buildCacheConfiguration: BuildCacheConfiguration;
-    projectConfiguration: RushProjectConfiguration;
+    project: RushConfigurationProject;
     projectOutputFolderNames: ReadonlyArray<string>;
     additionalProjectOutputFilePaths?: ReadonlyArray<string>;
     additionalContext?: Record<string, string>;
@@ -30,10 +30,11 @@ export declare class ProjectBuildCache {
     private _cacheId;
     private constructor();
     private static _tryGetTarUtility;
+    get cacheId(): string | undefined;
     static tryGetProjectBuildCache(options: IProjectBuildCacheOptions): Promise<ProjectBuildCache | undefined>;
     private static _validateProject;
-    tryRestoreFromCacheAsync(terminal: ITerminal): Promise<boolean>;
-    trySetCacheEntryAsync(terminal: ITerminal): Promise<boolean>;
+    tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
+    trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     /**
      * Walks the declared output folders of the project and collects a list of files.
      * @returns The list of output files as project-relative paths, or `undefined` if a

package/lib/logic/cobuild/CobuildLock.d.ts

@@ -0,0 +1,24 @@
+import type { CobuildConfiguration } from '../../api/CobuildConfiguration';
+import type { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import type { OperationStatus } from '../operations/OperationStatus';
+import type { ICobuildContext } from './ICobuildLockProvider';
+export interface ICobuildLockOptions {
+    cobuildConfiguration: CobuildConfiguration;
+    projectBuildCache: ProjectBuildCache;
+}
+export interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    cacheId: string;
+}
+export declare class CobuildLock {
+    readonly projectBuildCache: ProjectBuildCache;
+    readonly cobuildConfiguration: CobuildConfiguration;
+    private _cobuildContext;
+    constructor(options: ICobuildLockOptions);
+    setCompletedStateAsync(state: ICobuildCompletedState): Promise<void>;
+    getCompletedStateAsync(): Promise<ICobuildCompletedState | undefined>;
+    tryAcquireLockAsync(): Promise<boolean>;
+    renewLockAsync(): Promise<void>;
+    get cobuildContext(): ICobuildContext;
+}
+//# sourceMappingURL=CobuildLock.d.ts.map

package/lib/logic/cobuild/CobuildLock.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/cobuild/CobuildLock");

package/lib/logic/cobuild/ICobuildLockProvider.d.ts

@@ -0,0 +1,46 @@
+import type { OperationStatus } from '../operations/OperationStatus';
+/**
+ * @beta
+ */
+export interface ICobuildContext {
+    /**
+     * The contextId is provided by the monorepo maintainer, it reads from environment variable {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}.
+     * It ensure only the builds from the same given contextId cooperated. If user was more permissive,
+     * and wanted all PR and CI builds building anything with the same contextId to cooperate, then just
+     * set it to a static value.
+     */
+    contextId: string;
+    /**
+     * The id of cache. It should be keep same as the normal cacheId from ProjectBuildCache.
+     * Otherwise, there is a discrepancy in the success case then turning on cobuilds will
+     * fail to populate the normal build cache.
+     */
+    cacheId: string;
+    /**
+     * {@inheritdoc RushConstants.cobuildLockVersion}
+     */
+    version: number;
+}
+/**
+ * @beta
+ */
+export interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    /**
+     * Completed state points to the cache id that was used to store the build cache.
+     * Note: Cache failed builds in a separate cache id
+     */
+    cacheId: string;
+}
+/**
+ * @beta
+ */
+export interface ICobuildLockProvider {
+    connectAsync(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    acquireLockAsync(context: ICobuildContext): Promise<boolean>;
+    renewLockAsync(context: ICobuildContext): Promise<void>;
+    setCompletedStateAsync(context: ICobuildContext, state: ICobuildCompletedState): Promise<void>;
+    getCompletedStateAsync(context: ICobuildContext): Promise<ICobuildCompletedState | undefined>;
+}
+//# sourceMappingURL=ICobuildLockProvider.d.ts.map

package/lib/logic/cobuild/ICobuildLockProvider.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/cobuild/ICobuildLockProvider");

package/lib/logic/installManager/InstallHelpers.d.ts

@@ -3,6 +3,7 @@ import { RushConfiguration } from '../../api/RushConfiguration';
 import { RushGlobalFolder } from '../../api/RushGlobalFolder';
 export declare class InstallHelpers {
     static generateCommonPackageJson(rushConfiguration: RushConfiguration, dependencies?: Map<string, string>): void;
+    static generateCommonSplitPackageJson(rushConfiguration: RushConfiguration): void;
     static getPackageManagerEnvironment(rushConfiguration: RushConfiguration, options?: {
         debug?: boolean;
     }): NodeJS.ProcessEnv;

package/lib/logic/operations/AsyncOperationQueue.d.ts

@@ -1,6 +1,16 @@
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 /**
- * Implmentation of the async iteration protocol for a collection of IOperation objects.
+ * When the queue returns an unassigned operation, it means there is at least one remote executing operation,
+ * at this time, the caller has a chance to make a decision:
+ * 1. Manually invoke `tryGetRemoteExecutingOperation()` to get the remote executing operation.
+ * 2. If there is no remote executing operation available, wait for some time and return in callback, which
+ * internally invoke `assignOperations()` to assign new operations.
+ * NOTE: the caller must wait for some time to avoid busy loop and burn CPU cycles.
+ */
+export declare const UNASSIGNED_OPERATION: 'UNASSIGNED_OPERATION';
+export declare type IOperationIteratorResult = OperationExecutionRecord | typeof UNASSIGNED_OPERATION;
+/**
+ * Implementation of the async iteration protocol for a collection of IOperation objects.
  * The async iterator will wait for an operation to be ready for execution, or terminate if there are no more operations.
  *
  * @remarks
@@ -8,9 +18,12 @@ import { OperationExecutionRecord } from './OperationExecutionRecord';
  * it must manually invoke `assignOperations()` after performing the updates, otherwise iterators will
  * stall until another operations completes.
  */
-export declare class AsyncOperationQueue implements AsyncIterable<OperationExecutionRecord>, AsyncIterator<OperationExecutionRecord> {
+export declare class AsyncOperationQueue implements AsyncIterable<IOperationIteratorResult>, AsyncIterator<IOperationIteratorResult> {
     private readonly _queue;
     private readonly _pendingIterators;
+    private readonly _totalOperations;
+    private readonly _completedOperations;
+    private _isDone;
     /**
      * @param operations - The set of operations to be executed
      * @param sortFn - A function that sorts operations in reverse priority order:
@@ -23,17 +36,23 @@ export declare class AsyncOperationQueue implements AsyncIterable<OperationExecu
      * For use with `for await (const operation of taskQueue)`
      * @see {AsyncIterator}
      */
-    next(): Promise<IteratorResult<OperationExecutionRecord>>;
+    next(): Promise<IteratorResult<IOperationIteratorResult>>;
+    /**
+     * Set a callback to be invoked when one operation is completed.
+     * If all operations are completed, set the queue to done, resolve all pending iterators in next cycle.
+     */
+    complete(record: OperationExecutionRecord): void;
     /**
      * Routes ready operations with 0 dependencies to waiting iterators. Normally invoked as part of `next()`, but
      * if the caller does not update operation dependencies prior to calling `next()`, may need to be invoked manually.
      */
     assignOperations(): void;
+    tryGetRemoteExecutingOperation(): OperationExecutionRecord | undefined;
     /**
      * Returns this queue as an async iterator, such that multiple functions iterating this object concurrently
      * receive distinct iteration results.
      */
-    [Symbol.asyncIterator](): AsyncIterator<OperationExecutionRecord>;
+    [Symbol.asyncIterator](): AsyncIterator<IOperationIteratorResult>;
 }
 export interface IOperationSortFunction {
     /**

package/lib/logic/operations/CacheableOperationPlugin.d.ts

@@ -0,0 +1,21 @@
+import { CobuildLock } from '../cobuild/CobuildLock';
+import { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface IOperationBuildCacheContext {
+    isCacheWriteAllowed: boolean;
+    isCacheReadAllowed: boolean;
+    isSkipAllowed: boolean;
+    projectBuildCache: ProjectBuildCache | undefined;
+    cobuildLock: CobuildLock | undefined;
+}
+export declare class CacheableOperationPlugin implements IPhasedCommandPlugin {
+    private _buildCacheContextByOperationRunner;
+    apply(hooks: PhasedCommandHooks): void;
+    private _applyShellOperationRunner;
+    private _getBuildCacheContextByRunner;
+    private _getBuildCacheContextByRunnerOrThrow;
+    private _tryGetProjectBuildCacheAsync;
+    private _tryGetLogOnlyProjectBuildCacheAsync;
+    private _tryGetCobuildLockAsync;
+}
+//# sourceMappingURL=CacheableOperationPlugin.d.ts.map

package/lib/logic/operations/CacheableOperationPlugin.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/operations/CacheableOperationPlugin");

package/lib/logic/operations/IOperationRunner.d.ts

@@ -2,7 +2,7 @@ import type { StdioSummarizer } from '@rushstack/terminal';
 import type { CollatedWriter } from '@rushstack/stream-collator';
 import type { OperationStatus } from './OperationStatus';
 import type { OperationMetadataManager } from './OperationMetadataManager';
-import type { IStopwatchResult } from '../../utilities/Stopwatch';
+import type { Stopwatch } from '../../utilities/Stopwatch';
 /**
  * Information passed to the executing `IOperationRunner`
  *
@@ -34,7 +34,34 @@ export interface IOperationRunnerContext {
     /**
      * Object used to track elapsed time.
      */
-    stopwatch: IStopwatchResult;
+    stopwatch: Stopwatch;
+    /**
+     * The current execution status of an operation. Operations start in the 'ready' state,
+     * but can be 'blocked' if an upstream operation failed. It is 'executing' when
+     * the operation is executing. Once execution is complete, it is either 'success' or
+     * 'failure'.
+     */
+    status: OperationStatus;
+    /**
+     * Error which occurred while executing this operation, this is stored in case we need
+     * it later (for example to re-print errors at end of execution).
+     */
+    error?: Error;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<IOperationRunnerContext>;
+    /**
+     * The operation runner that is executing this operation.
+     */
+    readonly runner: IOperationRunner;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
@@ -48,10 +75,6 @@ export interface IOperationRunner {
      * Name of the operation, for logging.
      */
     readonly name: string;
-    /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
-     */
-    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -65,10 +88,6 @@ export interface IOperationRunner {
      * exit code
      */
     warningsAreAllowed: boolean;
-    /**
-     * Indicates if the output of this operation may be written to the cache
-     */
-    isCacheWriteAllowed: boolean;
     /**
      * Method to be executed for the operation.
      */

package/lib/logic/operations/OperationExecutionManager.d.ts

@@ -8,6 +8,8 @@ export interface IOperationExecutionManagerOptions {
     parallelism: number;
     changedProjectsOnly: boolean;
     destination?: TerminalWritable;
+    beforeExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
+    afterExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     beforeExecuteOperations?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
 }
@@ -27,11 +29,14 @@ export declare class OperationExecutionManager {
     private readonly _colorsNewlinesTransform;
     private readonly _streamCollator;
     private readonly _terminal;
+    private readonly _beforeExecuteOperation?;
+    private readonly _afterExecuteOperation?;
     private readonly _onOperationStatusChanged?;
     private readonly _beforeExecuteOperations?;
     private _hasAnyFailures;
     private _hasAnyNonAllowedWarnings;
     private _completedOperations;
+    private _executionQueue;
     constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
     private _streamCollator_onWriterActive;
     /**

package/lib/logic/operations/OperationExecutionRecord.d.ts

@@ -10,9 +10,12 @@ export interface IOperationExecutionRecordContext {
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     debugMode: boolean;
     quietMode: boolean;
+    changedProjectsOnly: boolean;
 }
 /**
  * Internal class representing everything about executing an operation
+ *
+ * @internal
  */
 export declare class OperationExecutionRecord implements IOperationRunnerContext {
     /**
@@ -37,6 +40,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * operation to execute, the operation with the highest criticalPathLength is chosen.
      *
      * Example:
+     * ```
      *        (0) A
      *             \
      *          (1) B     C (0)         (applications)
@@ -53,6 +57,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * X has a score of 1, since the only package which depends on it is A
      * Z has a score of 2, since only X depends on it, and X has a score of 1
      * Y has a score of 2, since the chain Y->X->C is longer than Y->C
+     * ```
      *
      * The algorithm is implemented in AsyncOperationQueue.ts as calculateCriticalPathLength()
      */
@@ -76,8 +81,9 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get name(): string;
     get debugMode(): boolean;
     get quietMode(): boolean;
+    get changedProjectsOnly(): boolean;
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
-    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
+    executeAsync(onResult: (record: OperationExecutionRecord) => Promise<void>): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

package/lib/logic/operations/OperationRunnerHooks.d.ts

@@ -0,0 +1,50 @@
+import { AsyncSeriesWaterfallHook } from 'tapable';
+import type { ITerminal } from '@rushstack/node-core-library';
+import type { IOperationRunnerContext } from './IOperationRunner';
+import type { OperationStatus } from './OperationStatus';
+import type { IProjectDeps, ShellOperationRunner } from './ShellOperationRunner';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+/**
+ * A plugin tht interacts with a operation runner
+ */
+export interface IOperationRunnerPlugin {
+    /**
+     * Applies this plugin.
+     */
+    apply(hooks: OperationRunnerHooks): void;
+}
+export interface IOperationRunnerBeforeExecuteContext {
+    context: IOperationRunnerContext;
+    runner: ShellOperationRunner;
+    earlyReturnStatus: OperationStatus | undefined;
+    terminal: ITerminal;
+    projectDeps: IProjectDeps | undefined;
+    lastProjectDeps: IProjectDeps | undefined;
+    trackedProjectFiles: string[] | undefined;
+    logPath: string;
+    errorLogPath: string;
+    rushProject: RushConfigurationProject;
+    phase: IPhase;
+    commandName: string;
+    commandToRun: string;
+}
+export interface IOperationRunnerAfterExecuteContext {
+    context: IOperationRunnerContext;
+    terminal: ITerminal;
+    /**
+     * Exit code of the operation command
+     */
+    exitCode: number;
+    status: OperationStatus;
+    taskIsSuccessful: boolean;
+}
+/**
+ * Hooks into the lifecycle of the operation runner
+ *
+ */
+export declare class OperationRunnerHooks {
+    beforeExecute: AsyncSeriesWaterfallHook<IOperationRunnerBeforeExecuteContext>;
+    afterExecute: AsyncSeriesWaterfallHook<IOperationRunnerAfterExecuteContext>;
+}
+//# sourceMappingURL=OperationRunnerHooks.d.ts.map

package/lib/logic/operations/OperationRunnerHooks.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/operations/OperationRunnerHooks");

package/lib/logic/operations/OperationStatus.d.ts

@@ -7,10 +7,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */

package/lib/logic/operations/PeriodicCallback.d.ts

@@ -0,0 +1,20 @@
+export declare type ICallbackFn = () => Promise<void> | void;
+export interface IPeriodicCallbackOptions {
+    interval: number;
+}
+/**
+ * A help class to run callbacks in a loop with a specified interval.
+ *
+ * @beta
+ */
+export declare class PeriodicCallback {
+    private _callbacks;
+    private _interval;
+    private _intervalId;
+    private _isRunning;
+    constructor(options: IPeriodicCallbackOptions);
+    addCallback(callback: ICallbackFn): void;
+    start(): void;
+    stop(): void;
+}
+//# sourceMappingURL=PeriodicCallback.d.ts.map

package/lib/logic/operations/PeriodicCallback.js

@@ -0,0 +1 @@
+module.exports = require("../../../lib-shim/index")._rushSdk_loadInternalModule("logic/operations/PeriodicCallback");

package/lib/logic/operations/ShellOperationRunner.d.ts

@@ -1,9 +1,10 @@
 import { OperationStatus } from './OperationStatus';
 import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import { PeriodicCallback } from './PeriodicCallback';
+import { OperationRunnerHooks } from './OperationRunnerHooks';
 import type { RushConfiguration } from '../../api/RushConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
-import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 import type { IPhase } from '../../api/CommandLineConfiguration';
 export interface IProjectDeps {
     files: {
@@ -14,9 +15,7 @@ export interface IProjectDeps {
 export interface IOperationRunnerOptions {
     rushProject: RushConfigurationProject;
     rushConfiguration: RushConfiguration;
-    buildCacheConfiguration: BuildCacheConfiguration | undefined;
     commandToRun: string;
-    isIncrementalBuildAllowed: boolean;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     displayName: string;
     phase: IPhase;
@@ -32,31 +31,23 @@ export interface IOperationRunnerOptions {
  */
 export declare class ShellOperationRunner implements IOperationRunner {
     readonly name: string;
-    isCacheWriteAllowed: boolean;
-    isSkipAllowed: boolean;
     readonly reportTiming: boolean;
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
+    readonly hooks: OperationRunnerHooks;
+    readonly periodicCallback: PeriodicCallback;
     private readonly _rushProject;
     private readonly _phase;
     private readonly _rushConfiguration;
-    private readonly _buildCacheConfiguration;
     private readonly _commandName;
     private readonly _commandToRun;
-    private readonly _isCacheReadAllowed;
     private readonly _projectChangeAnalyzer;
     private readonly _packageDepsFilename;
     private readonly _logFilenameIdentifier;
     private readonly _selectedPhases;
-    /**
-     * UNINITIALIZED === we haven't tried to initialize yet
-     * undefined === we didn't create one because the feature is not enabled
-     */
-    private _projectBuildCache;
     constructor(options: IOperationRunnerOptions);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     private _executeAsync;
-    private _tryGetProjectBuildCacheAsync;
 }
 /**
  * When running a command from the "scripts" block in package.json, if the command