@rushstack/rush-sdk 5.103.0 → 5.104.1

package/lib/api/EnvironmentConfiguration.d.ts

@@ -120,6 +120,33 @@ export declare const EnvironmentVariableNames: {
      * this environment variable is ignored.
      */
     readonly RUSH_BUILD_CACHE_WRITE_ALLOWED: "RUSH_BUILD_CACHE_WRITE_ALLOWED";
+    /**
+     * 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 +191,9 @@ export declare class EnvironmentConfiguration {
     private static _buildCacheCredential;
     private static _buildCacheEnabled;
     private static _buildCacheWriteAllowed;
+    private static _cobuildContextId;
+    private static _cobuildRunnerId;
+    private static _cobuildLeafProjectLogOnlyAllowed;
     private static _gitBinaryPath;
     private static _tarBinaryPath;
     /**
@@ -219,6 +249,21 @@ export declare class EnvironmentConfiguration {
      * See {@link EnvironmentVariableNames.RUSH_BUILD_CACHE_WRITE_ALLOWED}
      */
     static get buildCacheWriteAllowed(): 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/RushProjectConfiguration.d.ts

@@ -1,8 +1,9 @@
-import { ITerminal } from '@rushstack/node-core-library';
+import { type ITerminal } from '@rushstack/node-core-library';
 import { RushConfigurationProject } from './RushConfigurationProject';
 import type { IPhase } from './CommandLineConfiguration';
 /**
- * Describes the file structure for the "<project root>/config/rush-project.json" config file.
+ * Describes the file structure for the `<project root>/config/rush-project.json` config file.
+ * @internal
  */
 export interface IRushProjectJson {
     /**
@@ -26,6 +27,9 @@ export interface IRushProjectJson {
     disableBuildCacheForProject?: boolean;
     operationSettings?: IOperationSettings[];
 }
+/**
+ * @alpha
+ */
 export interface IOperationSettings {
     /**
      * The name of the operation. This should be a key in the `package.json`'s `scripts` object.
@@ -74,17 +78,17 @@ export interface IOperationSettings {
  * Use this class to load the "config/rush-project.json" config file.
  *
  * This file provides project-specific configuration options.
- * @public
+ * @alpha
  */
 export declare class RushProjectConfiguration {
     private static readonly _configCache;
     readonly project: RushConfigurationProject;
     /**
-     * {@inheritdoc IRushProjectJson.incrementalBuildIgnoredGlobs}
+     * {@inheritdoc _IRushProjectJson.incrementalBuildIgnoredGlobs}
      */
     readonly incrementalBuildIgnoredGlobs: ReadonlyArray<string>;
     /**
-     * {@inheritdoc IRushProjectJson.disableBuildCacheForProject}
+     * {@inheritdoc _IRushProjectJson.disableBuildCacheForProject}
      */
     readonly disableBuildCacheForProject: boolean;
     readonly operationSettingsByOperationName: ReadonlyMap<string, Readonly<IOperationSettings>>;
@@ -98,6 +102,11 @@ export declare class RushProjectConfiguration {
      * that are not used by "rush build" will not cause "rush build" to exit with an error.
      */
     validatePhaseConfiguration(phases: Iterable<IPhase>, terminal: ITerminal): void;
+    /**
+     * Examines the list of source files for the project and the target phase and returns a reason
+     * why the project cannot enable the build cache for that phase, or undefined if it is safe to so do.
+     */
+    getCacheDisabledReason(trackedFileNames: Iterable<string>, phaseName: string): string | undefined;
     /**
      * Loads the rush-project.json data for the specified project.
      */
@@ -111,6 +120,11 @@ export declare class RushProjectConfiguration {
      * having to validate the rest of the `rush-project.json` file against the repo's command-line configuration.
      */
     static tryLoadIgnoreGlobsForProjectAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<ReadonlyArray<string> | undefined>;
+    /**
+     * Load the rush-project.json data for all selected projects.
+     * Validate compatibility of output folders across all selected phases.
+     */
+    static tryLoadAndValidateForProjectsAsync(projects: Iterable<RushConfigurationProject>, phases: ReadonlySet<IPhase>, terminal: ITerminal): Promise<ReadonlyMap<RushConfigurationProject, RushProjectConfiguration>>;
     private static _tryLoadJsonForProjectAsync;
     private static _getRushProjectConfiguration;
 }

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';
@@ -16,6 +17,7 @@ export { EnvironmentConfiguration, EnvironmentVariableNames, IEnvironmentConfigu
 export { RushConstants } from './logic/RushConstants';
 export { PackageManagerName, PackageManager } from './api/packageManager/PackageManager';
 export { RushConfigurationProject } from './api/RushConfigurationProject';
+export { IRushProjectJson as _IRushProjectJson, IOperationSettings, RushProjectConfiguration } from './api/RushProjectConfiguration';
 export { RushUserConfiguration } from './api/RushUserConfiguration';
 export { RushGlobalFolder as _RushGlobalFolder } from './api/RushGlobalFolder';
 export { ApprovedPackagesItem, ApprovedPackagesConfiguration } from './api/ApprovedPackagesConfiguration';
@@ -32,12 +34,12 @@ 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 { ProjectChangeAnalyzer, IGetChangedProjectsOptions, IRawRepoState as _IRawRepoState } 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';
@@ -45,6 +47,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

@@ -154,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/buildCache/ProjectBuildCache.d.ts

@@ -1,15 +1,14 @@
 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>;
-    command: string;
-    trackedProjectFiles: string[] | undefined;
+    configHash: string;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     terminal: ITerminal;
     phaseName: string;
@@ -30,10 +29,10 @@ 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,51 @@
+import { ITerminal } from '@rushstack/node-core-library';
+import { CobuildLock } from '../cobuild/CobuildLock';
+import { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import { IOperationSettings } from '../../api/RushProjectConfiguration';
+import { ProjectLogWritable } from './ProjectLogWritable';
+import { CobuildConfiguration } from '../../api/CobuildConfiguration';
+import { PeriodicCallback } from './PeriodicCallback';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
+export interface IProjectDeps {
+    files: {
+        [filePath: string]: string;
+    };
+    arguments: string;
+}
+export interface IOperationBuildCacheContext {
+    isCacheWriteAllowed: boolean;
+    isCacheReadAllowed: boolean;
+    projectBuildCache: ProjectBuildCache | undefined;
+    cacheDisabledReason: string | undefined;
+    operationSettings: IOperationSettings | undefined;
+    cobuildLock: CobuildLock | undefined;
+    cobuildClusterId: string | undefined;
+    buildCacheTerminal: ITerminal | undefined;
+    buildCacheProjectLogWritable: ProjectLogWritable | undefined;
+    periodicCallback: PeriodicCallback;
+    cacheRestored: boolean;
+    isCacheReadAttempted: boolean;
+}
+export interface ICacheableOperationPluginOptions {
+    allowWarningsInSuccessfulBuild: boolean;
+    buildCacheConfiguration: BuildCacheConfiguration;
+    cobuildConfiguration: CobuildConfiguration | undefined;
+    terminal: ITerminal;
+}
+export declare class CacheableOperationPlugin implements IPhasedCommandPlugin {
+    private _buildCacheContextByOperation;
+    private _createContext;
+    private readonly _options;
+    constructor(options: ICacheableOperationPluginOptions);
+    apply(hooks: PhasedCommandHooks): void;
+    private _getBuildCacheContextByOperation;
+    private _getBuildCacheContextByOperationOrThrow;
+    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

@@ -1,12 +1,16 @@
 import type { StdioSummarizer } from '@rushstack/terminal';
 import type { OperationStatus } from './OperationStatus';
-import type { IStopwatchResult } from '../../utilities/Stopwatch';
 import type { Operation } from './Operation';
+import type { IStopwatchResult } from '../../utilities/Stopwatch';
 /**
  * The `IOperationExecutionResult` interface represents the results of executing an {@link Operation}.
  * @alpha
  */
 export interface IOperationExecutionResult {
+    /**
+     * The operation itself
+     */
+    readonly operation: Operation;
     /**
      * 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
@@ -31,6 +35,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.

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

@@ -35,6 +35,25 @@ export interface IOperationRunnerContext {
      * Object used to track elapsed time.
      */
     stopwatch: IStopwatchResult;
+    /**
+     * 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;
+    /**
+     * 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
@@ -49,9 +68,9 @@ export interface IOperationRunner {
      */
     readonly name: string;
     /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
+     * Whether or not the operation is cacheable. If false, all cache engines will be disabled for this operation.
      */
-    isSkipAllowed: boolean;
+    cacheable: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -65,13 +84,13 @@ 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.
      */
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+    /**
+     * Return a hash of the configuration that affects the operation.
+     */
+    getConfigHash(): string;
 }
 //# sourceMappingURL=IOperationRunner.d.ts.map

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

@@ -0,0 +1,22 @@
+import { type ITerminal } from '@rushstack/node-core-library';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface IProjectDeps {
+    files: {
+        [filePath: string]: string;
+    };
+    arguments: string;
+}
+export interface ILegacySkipPluginOptions {
+    terminal: ITerminal;
+    changedProjectsOnly: boolean;
+    isIncrementalBuildAllowed: boolean;
+}
+/**
+ * Core phased command plugin that implements the legacy skip detection logic, used when build cache is disabled.
+ */
+export declare class LegacySkipPlugin implements IPhasedCommandPlugin {
+    private readonly _options;
+    constructor(options: ILegacySkipPluginOptions);
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=LegacySkipPlugin.d.ts.map

package/lib/logic/operations/LegacySkipPlugin.js

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

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

@@ -25,11 +25,11 @@ export declare class NullOperationRunner implements IOperationRunner {
     readonly name: string;
     readonly reportTiming: boolean;
     readonly silent: boolean;
-    isSkipAllowed: boolean;
-    isCacheWriteAllowed: boolean;
+    cacheable: boolean;
     readonly warningsAreAllowed: boolean;
     readonly result: OperationStatus;
     constructor({ name, result, silent }: INullOperationRunnerParams);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+    getConfigHash(): string;
 }
 //# sourceMappingURL=NullOperationRunner.d.ts.map