@rushstack/rush-sdk 5.100.2 → 5.101.0-pr3949.3

package/dist/rush-sdk.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+
+/**
+ * Options for {@link RushSdkLoader.loadAsync}
+ * @public
+ */
+export declare interface ILoadSdkAsyncOptions {
+    /**
+     * The folder to start from when searching for the Rush workspace configuration.
+     * If this folder does not contain a `rush.json` file, then each parent folder
+     * will be searched.  If `rush.json` is not found, then the SDK fails to load.
+     */
+    rushJsonSearchFolder?: string;
+    /**
+     * A cancellation token that the caller can use to prematurely abort the operation.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Allows the caller to monitor the progress of the operation.
+     */
+    onNotifyEvent?: SdkNotifyEventCallback;
+}
+
+/**
+ * Type of {@link ISdkCallbackEvent.logMessage}
+ * @public
+ */
+export declare interface IProgressBarCallbackLogMessage {
+    /**
+     * A status message to print in the log window, or `undefined` if there are
+     * no further messages.  This string may contain newlines.
+     */
+    text: string;
+    /**
+     * The type of message.  More message types may be added in the future.
+     */
+    kind: 'info' | 'debug';
+}
+
+/**
+ * Event options for {@link ILoadSdkAsyncOptions.onNotifyEvent}
+ * @public
+ */
+export declare interface ISdkCallbackEvent {
+    /**
+     * Allows the caller to display log information about the operation.
+     */
+    logMessage: IProgressBarCallbackLogMessage | undefined;
+    /**
+     * Allows the caller to display a progress bar for long-running operations.
+     *
+     * @remarks
+     * If a long-running operation is required, then `progressPercent` will
+     * start at 0.0 and count upwards and finish at 100.0 if the operation completes
+     * successfully.  If the long-running operation has not yet started, or
+     * is not required, then the value will be `undefined`.
+     */
+    progressPercent: number | undefined;
+}
+
+/**
+ * Exposes operations that control how the `@microsoft/rush-lib` engine is
+ * located and loaded.
+ * @public
+ */
+export declare class RushSdkLoader {
+    /**
+     * Throws an "AbortError" exception if abortSignal.aborted is true.
+     */
+    private static _checkForCancel;
+    /**
+     * Returns true if the Rush engine has already been loaded.
+     */
+    static get isLoaded(): boolean;
+    /**
+     * Manually load the Rush engine based on rush.json found for `rushJsonSearchFolder`.
+     * Throws an exception if {@link RushSdkLoader.isLoaded} is already `true`.
+     *
+     * @remarks
+     * This API supports an callback that can be used display a progress bar,
+     * log of operations, and allow the operation to be canceled prematurely.
+     */
+    static loadAsync(options?: ILoadSdkAsyncOptions): Promise<void>;
+}
+
+/**
+ * Type of {@link ILoadSdkAsyncOptions.onNotifyEvent}
+ * @public
+ */
+export declare type SdkNotifyEventCallback = (sdkEvent: ISdkCallbackEvent) => void;
+
+export { }

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.36.4"
+    }
+  ]
+}

package/lib/api/CobuildConfiguration.d.ts

@@ -0,0 +1,71 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { CobuildLockProviderFactory, RushSession } from '../pluginFramework/RushSession';
+import type { ICobuildLockProvider } from '../logic/cobuild/ICobuildLockProvider';
+import type { RushConfiguration } from './RushConfiguration';
+/**
+ * @beta
+ */
+export interface ICobuildJson {
+    cobuildEnabled: boolean;
+    cobuildLockProvider: string;
+}
+/**
+ * @beta
+ */
+export interface ICobuildConfigurationOptions {
+    cobuildJson: ICobuildJson;
+    rushConfiguration: RushConfiguration;
+    rushSession: RushSession;
+    cobuildLockProviderFactory: CobuildLockProviderFactory;
+}
+/**
+ * Use this class to load and save the "common/config/rush/cobuild.json" config file.
+ * This file provides configuration options for the Rush Cobuild feature.
+ * @beta
+ */
+export declare class CobuildConfiguration {
+    private static _jsonSchema;
+    /**
+     * Indicates whether the cobuild feature is enabled.
+     * Typically it is enabled in the cobuild.json config file.
+     *
+     * Note: The orchestrator (or local users) should always have to opt into running with cobuilds by
+     * providing a cobuild context id. Even if cobuilds are "enabled" as a feature, they don't
+     * actually turn on for that particular build unless the cobuild context id is provided as an
+     * non-empty string.
+     */
+    readonly cobuildEnabled: boolean;
+    /**
+     * Cobuild context id
+     *
+     * @remarks
+     * The cobuild feature won't be enabled until the context id is provided as an non-empty string.
+     */
+    readonly cobuildContextId: string | undefined;
+    /**
+     * This is a name of the participating cobuild runner. It can be specified by the environment variable
+     * RUSH_COBUILD_RUNNER_ID. If it is not provided, a random id will be generated to identify the runner.
+     */
+    readonly cobuildRunnerId: string;
+    /**
+     * If true, 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 cobuildLeafProjectLogOnlyAllowed: boolean;
+    private _cobuildLockProvider;
+    private readonly _cobuildLockProviderFactory;
+    private readonly _cobuildJson;
+    private constructor();
+    /**
+     * Attempts to load the cobuild.json data from the standard file path `common/config/rush/cobuild.json`.
+     * If the file has not been created yet, then undefined is returned.
+     */
+    static tryLoadAsync(terminal: ITerminal, rushConfiguration: RushConfiguration, rushSession: RushSession): Promise<CobuildConfiguration | undefined>;
+    static getCobuildConfigFilePath(rushConfiguration: RushConfiguration): string;
+    private static _loadAsync;
+    createLockProviderAsync(terminal: ITerminal): Promise<void>;
+    destroyLockProviderAsync(): Promise<void>;
+    get cobuildLockProvider(): ICobuildLockProvider;
+}
+//# sourceMappingURL=CobuildConfiguration.d.ts.map

package/lib/api/CobuildConfiguration.js

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

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/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';
@@ -36,7 +37,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 +45,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

@@ -148,6 +148,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/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/deploy/DeployScenarioConfiguration.d.ts

@@ -5,6 +5,8 @@ export interface IDeployScenarioProjectJson {
     additionalProjectsToInclude?: string[];
     additionalDependenciesToInclude?: string[];
     dependenciesToExclude?: string[];
+    patternsToInclude?: string[];
+    patternsToExclude?: string[];
 }
 export interface IDeployScenarioJson {
     deploymentProjectNames: string[];

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,30 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { CobuildLock } from '../cobuild/CobuildLock';
+import { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import { ProjectLogWritable } from './ProjectLogWritable';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface IOperationBuildCacheContext {
+    isCacheWriteAllowed: boolean;
+    isCacheReadAllowed: boolean;
+    isSkipAllowed: boolean;
+    projectBuildCache: ProjectBuildCache | undefined;
+    cobuildLock: CobuildLock | undefined;
+    cobuildClusterId: string | undefined;
+    buildCacheTerminal: ITerminal | undefined;
+    buildCacheProjectLogWritable: ProjectLogWritable | undefined;
+}
+export declare class CacheableOperationPlugin implements IPhasedCommandPlugin {
+    private _buildCacheContextByOperationRunner;
+    apply(hooks: PhasedCommandHooks): void;
+    private _applyShellOperationRunner;
+    private _getBuildCacheContextByRunner;
+    private _getBuildCacheContextByRunnerOrThrow;
+    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.