@rushstack/rush-sdk 5.101.0 → 5.102.0-pr3949.4

package/lib/api/CustomTipsConfiguration.d.ts

@@ -0,0 +1,89 @@
+import { ITerminal } from '@rushstack/node-core-library';
+/**
+ * This interface represents the raw custom-tips.json file which allows repo maintainers
+ * to configure extra details to be printed alongside certain Rush messages.
+ * @beta
+ */
+export interface ICustomTipsJson {
+    /**
+     * If specified, this prefix will be prepended to any the tip messages when they are displayed.
+     * The default value is an empty string.
+     */
+    defaultMessagePrefix?: string;
+    /**
+     *  Specifies the custom tips to be displayed by Rush.
+     */
+    customTips?: ICustomTipItemJson[];
+}
+/**
+ * An item from the {@link ICustomTipsJson.customTips} list.
+ * @beta
+ */
+export interface ICustomTipItemJson {
+    /**
+     * (REQUIRED) An identifier indicating a message that may be printed by Rush.
+     * If that message is printed, then this custom tip will be shown.
+     * Consult the Rush documentation for the current list of possible identifiers.
+     */
+    tipId: CustomTipId;
+    /**
+     * (REQUIRED) The message text to be displayed for this tip.
+     */
+    message: string;
+    /**
+     *  Overrides the "defaultMessagePrefix" for this tip.
+     * Specify an empty string to omit the "defaultMessagePrefix" entirely.
+     */
+    messagePrefix?: string;
+}
+/**
+ * An identifier representing a Rush message that can be customized by
+ * defining a custom tip in `common/config/rush/custom-tips.json`.
+ * @remarks
+ * Custom tip ids always start with the `TIP_` prefix.
+ *
+ * @privateRemarks
+ * Events from the Rush process should with "TIP_RUSH_".
+ * Events from a PNPM subprocess should start with "TIP_PNPM_".
+ *
+ * @beta
+ */
+export type CustomTipId = 'TIP_RUSH_INCONSISTENT_VERSIONS' | string;
+/**
+ * Used to access the `common/config/rush/custom-tips.json` config file,
+ * which allows repo maintainers to configure extra details to be printed alongside
+ * certain Rush messages.
+ * @beta
+ */
+export declare class CustomTipsConfiguration {
+    private static _jsonSchema;
+    private readonly _tipMap;
+    private readonly _jsonFileName;
+    /**
+     * The JSON settings loaded from `custom-tips.json`.
+     */
+    readonly configuration: Readonly<ICustomTipsJson>;
+    /**
+     * The list of identifiers that are allowed to be used in the "tipId" field
+     * of the config file.
+     */
+    static readonly supportedTipIds: ReadonlySet<string>;
+    constructor(configFilename: string);
+    private _formatTipMessage;
+    /**
+     * If custom-tips.json defines a tip for the specified tipId,
+     * display the tip on the terminal.
+     */
+    showInfoTip(terminal: ITerminal, tipId: CustomTipId): void;
+    /**
+     * If custom-tips.json defines a tip for the specified tipId,
+     * display the tip on the terminal.
+     */
+    showWarningTip(terminal: ITerminal, tipId: CustomTipId): void;
+    /**
+     * If custom-tips.json defines a tip for the specified tipId,
+     * display the tip on the terminal.
+     */
+    showErrorTip(terminal: ITerminal, tipId: CustomTipId): void;
+}
+//# sourceMappingURL=CustomTipsConfiguration.d.ts.map

package/lib/api/CustomTipsConfiguration.js

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

package/lib/api/EnvironmentConfiguration.d.ts

@@ -120,6 +120,43 @@ export declare const EnvironmentVariableNames: {
      * this environment variable is ignored.
      */
     readonly RUSH_BUILD_CACHE_WRITE_ALLOWED: "RUSH_BUILD_CACHE_WRITE_ALLOWED";
+    /**
+     * Setting this environment variable overrides the value of `cobuildEnabled` in the `cobuild.json`
+     * configuration file.
+     *
+     * @remarks
+     * Specify `1` to enable the cobuild or `0` to disable it.
+     *
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_ENABLED: "RUSH_COBUILD_ENABLED";
+    /**
+     * Setting this environment variable opts into running with cobuilds. The context id should be the same across
+     * multiple VMs, but changed when it is a new round of cobuilds.
+     *
+     * e.g. `Build.BuildNumber` in Azure DevOps Pipeline.
+     *
+     * @remarks
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_CONTEXT_ID: "RUSH_COBUILD_CONTEXT_ID";
+    /**
+     * Explicitly specifies a name for each participating cobuild runner.
+     *
+     * Setting this environment variable opts into running with cobuilds.
+     *
+     * @remarks
+     * This environment variable is optional, if it is not provided, a random id is used.
+     *
+     * If there is no cobuild configured, then this environment variable is ignored.
+     */
+    readonly RUSH_COBUILD_RUNNER_ID: "RUSH_COBUILD_RUNNER_ID";
+    /**
+     * If this variable is set to "1", When getting distributed builds, Rush will automatically handle the leaf project
+     * with build cache "disabled" by writing to the cache in a special "log files only mode". This is useful when you
+     * want to use Cobuilds to improve the performance in CI validations and the leaf projects have not enabled cache.
+     */
+    readonly RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED: "RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED";
     /**
      * Explicitly specifies the path for the Git binary that is invoked by certain Rush operations.
      */
@@ -164,6 +201,10 @@ export declare class EnvironmentConfiguration {
     private static _buildCacheCredential;
     private static _buildCacheEnabled;
     private static _buildCacheWriteAllowed;
+    private static _cobuildEnabled;
+    private static _cobuildContextId;
+    private static _cobuildRunnerId;
+    private static _cobuildLeafProjectLogOnlyAllowed;
     private static _gitBinaryPath;
     private static _tarBinaryPath;
     /**
@@ -219,6 +260,26 @@ export declare class EnvironmentConfiguration {
      * See {@link EnvironmentVariableNames.RUSH_BUILD_CACHE_WRITE_ALLOWED}
      */
     static get buildCacheWriteAllowed(): boolean | undefined;
+    /**
+     * If set, enables or disables the cobuild feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_ENABLED}
+     */
+    static get cobuildEnabled(): boolean | undefined;
+    /**
+     * Provides a determined cobuild context id if configured
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_CONTEXT_ID}
+     */
+    static get cobuildContextId(): string | undefined;
+    /**
+     * Provides a determined cobuild runner id if configured
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_RUNNER_ID}
+     */
+    static get cobuildRunnerId(): string | undefined;
+    /**
+     * If set, enables or disables the cobuild leaf project log only feature.
+     * See {@link EnvironmentVariableNames.RUSH_COBUILD_LEAF_PROJECT_LOG_ONLY_ALLOWED}
+     */
+    static get cobuildLeafProjectLogOnlyAllowed(): boolean | undefined;
     /**
      * Allows the git binary path to be explicitly provided.
      * See {@link EnvironmentVariableNames.RUSH_GIT_BINARY_PATH}

package/lib/api/ExperimentsConfiguration.d.ts

@@ -14,6 +14,12 @@ export interface IExperimentsJson {
      * Set this option to true to pass '--prefer-frozen-lockfile' instead.
      */
     usePnpmPreferFrozenLockfileForRushUpdate?: boolean;
+    /**
+     * By default, 'rush update' runs as a single operation.
+     * Set this option to true to instead update the lockfile with `--lockfile-only`, then perform a `--frozen-lockfile` install.
+     * Necessary when using the `afterAllResolved` hook in .pnpmfile.cjs.
+     */
+    usePnpmLockfileOnlyThenFrozenLockfileForRushUpdate?: boolean;
     /**
      * If using the 'preventManualShrinkwrapChanges' option, restricts the hash to only include the layout of external dependencies.
      * Used to allow links between workspace projects or the addition/removal of references to existing dependency versions to not

package/lib/api/RushConfiguration.d.ts

@@ -13,6 +13,7 @@ import { IPnpmOptionsJson, PnpmOptionsConfiguration } from '../logic/pnpm/PnpmOp
 import { INpmOptionsJson, NpmOptionsConfiguration } from '../logic/npm/NpmOptionsConfiguration';
 import { IYarnOptionsJson, YarnOptionsConfiguration } from '../logic/yarn/YarnOptionsConfiguration';
 import { PackageManagerOptionsConfigurationBase } from '../logic/base/BasePackageManagerOptionsConfiguration';
+import { CustomTipsConfiguration } from './CustomTipsConfiguration';
 /**
  * Part of IRushConfigurationJson.
  */
@@ -413,6 +414,16 @@ export declare class RushConfiguration {
      * @beta
      */
     readonly versionPolicyConfigurationFilePath: string;
+    /**
+     * Accesses the custom-tips.json configuration.
+     * @beta
+     */
+    readonly customTipsConfiguration: CustomTipsConfiguration;
+    /**
+     * The absolute path to the custom tips configuration file.
+     * @beta
+     */
+    readonly customTipsConfigurationFilePath: string;
     /**
      * This configuration object contains settings repo maintainers have specified to enable
      * and disable experimental Rush features.

package/lib/cli/actions/BaseInstallAction.d.ts

@@ -2,10 +2,12 @@ import type { CommandLineFlagParameter, CommandLineIntegerParameter, CommandLine
 import { BaseRushAction, IBaseRushActionOptions } from './BaseRushAction';
 import type { IInstallManagerOptions } from '../../logic/base/BaseInstallManagerTypes';
 import { SelectionParameterSet } from '../parsing/SelectionParameterSet';
+import { ITerminal } from '@rushstack/node-core-library';
 /**
  * This is the common base class for InstallAction and UpdateAction.
  */
 export declare abstract class BaseInstallAction extends BaseRushAction {
+    protected readonly _terminal: ITerminal;
     protected readonly _variant: CommandLineStringParameter;
     protected readonly _purgeParameter: CommandLineFlagParameter;
     protected readonly _bypassPolicyParameter: CommandLineFlagParameter;

package/lib/cli/actions/CheckAction.d.ts

@@ -1,6 +1,7 @@
 import { RushCommandLineParser } from '../RushCommandLineParser';
 import { BaseRushAction } from './BaseRushAction';
 export declare class CheckAction extends BaseRushAction {
+    private readonly _terminal;
     private readonly _variant;
     private readonly _jsonFlag;
     private readonly _verboseFlag;

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, PhaseBehaviorForMissingScript as IPhaseBehaviorForMissingScript } from './api/CommandLineConfiguration';
@@ -31,12 +32,13 @@ export { VersionPolicyConfiguration } from './api/VersionPolicyConfiguration';
 export { ILaunchOptions, Rush } from './api/Rush';
 export { RushInternals as _RushInternals } from './api/RushInternals';
 export { ExperimentsConfiguration, IExperimentsJson } from './api/ExperimentsConfiguration';
+export { CustomTipsConfiguration, CustomTipId, ICustomTipsJson, ICustomTipItemJson } from './api/CustomTipsConfiguration';
 export { ProjectChangeAnalyzer, IGetChangedProjectsOptions } from './logic/ProjectChangeAnalyzer';
 export { IOperationRunner, IOperationRunnerContext } from './logic/operations/IOperationRunner';
 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/RushConstants.d.ts

@@ -108,6 +108,12 @@ export declare class RushConstants {
      * store the state of various features as they stand in the repo.
      */
     static readonly repoStateFilename: string;
+    /**
+     * The filename ("custom-tips.json") for the file used by Rush to
+     * print user-customized messages.
+     * This configuration file should go in the "common/config/rush" folder.
+     */
+    static readonly customTipsFilename: string;
     /**
      * The name of the per-project folder where project-specific Rush files are stored. For example,
      * the package-deps files, which are used by commands to determine if a particular project needs to be rebuilt.
@@ -148,6 +154,10 @@ 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;
     /**
      * Per-project configuration filename.
      */

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

@@ -29,6 +29,10 @@ export interface IInstallManagerOptions {
      * will be upgraded to the latest SemVer-compatible version.
      */
     fullUpgrade: boolean;
+    /**
+     * If set, only update the shrinkwrap file; do not create node_modules.
+     */
+    onlyShrinkwrap?: boolean;
     /**
      * Whether to force an update to the shrinkwrap file even if it appears to be unnecessary.
      * Normally Rush uses heuristics to determine when "pnpm install" can be skipped,

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,43 @@
+import type { CobuildConfiguration } from '../../api/CobuildConfiguration';
+import type { OperationStatus } from '../operations/OperationStatus';
+import type { ICobuildContext } from './ICobuildLockProvider';
+import type { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+export interface ICobuildLockOptions {
+    /**
+     * {@inheritdoc CobuildConfiguration}
+     */
+    cobuildConfiguration: CobuildConfiguration;
+    /**
+     * {@inheritdoc ICobuildContext.clusterId}
+     */
+    cobuildClusterId: string;
+    /**
+     * {@inheritdoc ICobuildContext.packageName}
+     */
+    packageName: string;
+    /**
+     * {@inheritdoc ICobuildContext.phaseName}
+     */
+    phaseName: string;
+    projectBuildCache: ProjectBuildCache;
+    /**
+     * The expire time of the lock in seconds.
+     */
+    lockExpireTimeInSeconds: number;
+}
+export interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    cacheId: string;
+}
+export declare class CobuildLock {
+    readonly cobuildConfiguration: CobuildConfiguration;
+    readonly projectBuildCache: ProjectBuildCache;
+    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/DisjointSet.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A disjoint set data structure
+ */
+export declare class DisjointSet<T extends object> {
+    private _forest;
+    private _parentMap;
+    private _sizeMap;
+    private _setByElement;
+    constructor();
+    destroy(): void;
+    /**
+     * Adds a new set containing specific object
+     */
+    add(x: T): void;
+    /**
+     * Unions the sets that contain two objects
+     */
+    union(a: T, b: T): void;
+    getAllSets(): Iterable<Set<T>>;
+    /**
+     * Returns true if x and y are in the same set
+     */
+    isConnected(x: T, y: T): boolean;
+    private _find;
+    private _getParent;
+    private _getSize;
+}
+//# sourceMappingURL=DisjointSet.d.ts.map

package/lib/logic/cobuild/DisjointSet.js

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

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

@@ -0,0 +1,99 @@
+import type { OperationStatus } from '../operations/OperationStatus';
+/**
+ * @beta
+ */
+export interface ICobuildContext {
+    /**
+     * The key for acquiring lock.
+     */
+    lockKey: string;
+    /**
+     * The expire time of the lock in seconds.
+     */
+    lockExpireTimeInSeconds: number;
+    /**
+     * The key for storing completed state.
+     */
+    completedStateKey: string;
+    /**
+     * 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.
+     */
+    contextId: string;
+    /**
+     * The id of the cluster. The operations in the same cluster share the same clusterId and
+     * will be executed on the same machine.
+     */
+    clusterId: string;
+    /**
+     * The id of the runner. The identifier for the running machine.
+     *
+     * It can be specified via assigning `RUSH_COBUILD_RUNNER_ID` environment variable.
+     */
+    runnerId: string;
+    /**
+     * The id of the cache entry. It should be kept the same as the normal cacheId from ProjectBuildCache.
+     * Otherwise, there is a discrepancy in the success case wherein turning on cobuilds will
+     * fail to populate the normal build cache.
+     */
+    cacheId: string;
+    /**
+     * The name of NPM package
+     *
+     * Example: `@scope/MyProject`
+     */
+    packageName: string;
+    /**
+     * The name of the phase.
+     *
+     * Example: _phase:build
+     */
+    phaseName: string;
+}
+/**
+ * @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 {
+    /**
+     * The callback function invoked to connect to the lock provider.
+     * For example, initializing the connection to the redis server.
+     */
+    connectAsync(): Promise<void>;
+    /**
+     * The callback function invoked to disconnect the lock provider.
+     */
+    disconnectAsync(): Promise<void>;
+    /**
+     * The callback function to acquire a lock with a lock key and specific contexts.
+     *
+     * NOTE: This lock implementation must be a ReentrantLock. It says the lock might be acquired
+     * multiple times, since tasks in the same cluster can be run in the same VM.
+     */
+    acquireLockAsync(context: Readonly<ICobuildContext>): Promise<boolean>;
+    /**
+     * The callback function to renew a lock with a lock key and specific contexts.
+     *
+     * NOTE: If the lock key expired
+     */
+    renewLockAsync(context: Readonly<ICobuildContext>): Promise<void>;
+    /**
+     * The callback function to set completed state.
+     */
+    setCompletedStateAsync(context: Readonly<ICobuildContext>, state: ICobuildCompletedState): Promise<void>;
+    /**
+     * The callback function to get completed state.
+     */
+    getCompletedStateAsync(context: Readonly<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/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 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,41 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { CobuildLock } from '../cobuild/CobuildLock';
+import { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import { ProjectLogWritable } from './ProjectLogWritable';
+import { PeriodicCallback } from './PeriodicCallback';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface IProjectDeps {
+    files: {
+        [filePath: string]: string;
+    };
+    arguments: string;
+}
+export interface IOperationBuildCacheContext {
+    isCacheWriteAllowed: boolean;
+    isCacheReadAllowed: boolean;
+    isSkipAllowed: boolean;
+    projectBuildCache: ProjectBuildCache | undefined;
+    cobuildLock: CobuildLock | undefined;
+    cobuildClusterId: string | undefined;
+    buildCacheTerminal: ITerminal | undefined;
+    buildCacheProjectLogWritable: ProjectLogWritable | undefined;
+    periodicCallback: PeriodicCallback;
+    projectDeps: IProjectDeps | undefined;
+    currentDepsPath: string | undefined;
+    cacheRestored: boolean;
+}
+export declare class CacheableOperationPlugin implements IPhasedCommandPlugin {
+    private _buildCacheContextByOperationExecutionRecord;
+    private _createContext;
+    apply(hooks: PhasedCommandHooks): void;
+    private _getBuildCacheContextByOperationExecutionRecord;
+    private _getBuildCacheContextByOperationExecutionRecordOrThrow;
+    private _tryGetProjectBuildCacheEnabledAsync;
+    private _tryGetProjectBuildCacheAsync;
+    private _tryGetLogOnlyProjectBuildCacheAsync;
+    private _tryGetCobuildLockAsync;
+    private _getBuildCacheTerminal;
+    private _createBuildCacheTerminal;
+    private _tryGetBuildCacheProjectLogWritable;
+}
+//# 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/IOperationExecutionResult.d.ts

@@ -31,6 +31,10 @@ export interface IOperationExecutionResult {
      * The value indicates the duration of the same operation without cache hit.
      */
     readonly nonCachedDurationMs: number | undefined;
+    /**
+     * The id of the runner which actually runs the building process in cobuild mode.
+     */
+    readonly cobuildRunnerId: string | undefined;
 }
 /**
  * The `IExecutionResult` interface represents the results of executing a set of {@link Operation}s.