@rushstack/rush-sdk 5.102.0-pr3949.7 → 5.103.0

package/lib/api/EnvironmentConfiguration.d.ts

@@ -120,43 +120,6 @@ 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.
      */
@@ -201,10 +164,6 @@ 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;
     /**
@@ -260,26 +219,6 @@ 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/RushProjectConfiguration.d.ts

@@ -1,9 +1,8 @@
-import { type ITerminal } from '@rushstack/node-core-library';
+import { 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.
- * @internal
+ * Describes the file structure for the "<project root>/config/rush-project.json" config file.
  */
 export interface IRushProjectJson {
     /**
@@ -27,9 +26,6 @@ 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.
@@ -78,17 +74,17 @@ export interface IOperationSettings {
  * Use this class to load the "config/rush-project.json" config file.
  *
  * This file provides project-specific configuration options.
- * @alpha
+ * @public
  */
 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>>;
@@ -102,11 +98,6 @@ 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.
      */
@@ -120,11 +111,6 @@ 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,7 +9,6 @@ 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';
@@ -17,7 +16,6 @@ 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';
@@ -34,12 +32,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, IRawRepoState as _IRawRepoState } from './logic/ProjectChangeAnalyzer';
+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, CobuildLockProviderFactory } from './pluginFramework/RushSession';
+export { RushSession, IRushSessionOptions, CloudBuildCacheProviderFactory } from './pluginFramework/RushSession';
 export { IRushCommand, IGlobalCommand, IPhasedCommand, RushLifecycleHooks } from './pluginFramework/RushLifeCycle';
 export { ICreateOperationsContext, PhasedCommandHooks } from './pluginFramework/PhasedCommandHooks';
 export { IRushPlugin } from './pluginFramework/IRushPlugin';
@@ -47,7 +45,6 @@ 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,10 +154,6 @@ 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,14 +1,15 @@
 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;
-    project: RushConfigurationProject;
+    projectConfiguration: RushProjectConfiguration;
     projectOutputFolderNames: ReadonlyArray<string>;
     additionalProjectOutputFilePaths?: ReadonlyArray<string>;
     additionalContext?: Record<string, string>;
-    configHash: string;
+    command: string;
+    trackedProjectFiles: string[] | undefined;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     terminal: ITerminal;
     phaseName: string;
@@ -29,10 +30,10 @@ export declare class ProjectBuildCache {
     private _cacheId;
     private constructor();
     private static _tryGetTarUtility;
-    get cacheId(): string | undefined;
     static tryGetProjectBuildCache(options: IProjectBuildCacheOptions): Promise<ProjectBuildCache | undefined>;
-    tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
-    trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
+    private static _validateProject;
+    tryRestoreFromCacheAsync(terminal: ITerminal): Promise<boolean>;
+    trySetCacheEntryAsync(terminal: ITerminal): 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/operations/AsyncOperationQueue.d.ts

@@ -1,16 +1,6 @@
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 /**
- * 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.
+ * Implmentation 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
@@ -18,12 +8,9 @@ export type IOperationIteratorResult = OperationExecutionRecord | typeof UNASSIG
  * it must manually invoke `assignOperations()` after performing the updates, otherwise iterators will
  * stall until another operations completes.
  */
-export declare class AsyncOperationQueue implements AsyncIterable<IOperationIteratorResult>, AsyncIterator<IOperationIteratorResult> {
+export declare class AsyncOperationQueue implements AsyncIterable<OperationExecutionRecord>, AsyncIterator<OperationExecutionRecord> {
     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:
@@ -36,23 +23,17 @@ export declare class AsyncOperationQueue implements AsyncIterable<IOperationIter
      * For use with `for await (const operation of taskQueue)`
      * @see {AsyncIterator}
      */
-    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;
+    next(): Promise<IteratorResult<OperationExecutionRecord>>;
     /**
      * 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<IOperationIteratorResult>;
+    [Symbol.asyncIterator](): AsyncIterator<OperationExecutionRecord>;
 }
 export interface IOperationSortFunction {
     /**

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

@@ -1,16 +1,12 @@
 import type { StdioSummarizer } from '@rushstack/terminal';
 import type { OperationStatus } from './OperationStatus';
-import type { Operation } from './Operation';
 import type { IStopwatchResult } from '../../utilities/Stopwatch';
+import type { Operation } from './Operation';
 /**
  * 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
@@ -35,10 +31,6 @@ 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,25 +35,6 @@ 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
@@ -68,9 +49,9 @@ export interface IOperationRunner {
      */
     readonly name: string;
     /**
-     * Whether or not the operation is cacheable. If false, all cache engines will be disabled for this operation.
+     * This flag determines if the operation is allowed to be skipped if up to date.
      */
-    cacheable: boolean;
+    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -85,12 +66,12 @@ export interface IOperationRunner {
      */
     warningsAreAllowed: boolean;
     /**
-     * Method to be executed for the operation.
+     * Indicates if the output of this operation may be written to the cache
      */
-    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
+    isCacheWriteAllowed: boolean;
     /**
-     * Return a hash of the configuration that affects the operation.
+     * Method to be executed for the operation.
      */
-    getConfigHash(): string;
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
 }
 //# sourceMappingURL=IOperationRunner.d.ts.map

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;
-    cacheable: boolean;
+    isSkipAllowed: boolean;
+    isCacheWriteAllowed: boolean;
     readonly warningsAreAllowed: boolean;
     readonly result: OperationStatus;
     constructor({ name, result, silent }: INullOperationRunnerParams);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
-    getConfigHash(): string;
 }
 //# sourceMappingURL=NullOperationRunner.d.ts.map

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

@@ -1,6 +1,5 @@
 import { TerminalWritable } from '@rushstack/terminal';
 import { Operation } from './Operation';
-import { OperationStatus } from './OperationStatus';
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 import { IExecutionResult } from './IOperationExecutionResult';
 export interface IOperationExecutionManagerOptions {
@@ -9,8 +8,6 @@ export interface IOperationExecutionManagerOptions {
     parallelism: number;
     changedProjectsOnly: boolean;
     destination?: TerminalWritable;
-    beforeExecuteOperation?: (operation: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
-    afterExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     beforeExecuteOperations?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
 }
@@ -30,14 +27,11 @@ 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

@@ -5,25 +5,16 @@ import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 import { Operation } from './Operation';
 import { Stopwatch } from '../../utilities/Stopwatch';
 import { OperationMetadataManager } from './OperationMetadataManager';
-import type { IPhase } from '../../api/CommandLineConfiguration';
-import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 export interface IOperationExecutionRecordContext {
     streamCollator: StreamCollator;
     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 {
-    /**
-     * The associated operation.
-     */
-    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
@@ -46,7 +37,6 @@ 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)
@@ -63,7 +53,6 @@ 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()
      */
@@ -80,8 +69,6 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     readonly stdioSummarizer: StdioSummarizer;
     readonly runner: IOperationRunner;
     readonly weight: number;
-    readonly associatedPhase: IPhase | undefined;
-    readonly associatedProject: RushConfigurationProject | undefined;
     readonly _operationMetadataManager: OperationMetadataManager | undefined;
     private readonly _context;
     private _collatedWriter;
@@ -89,13 +76,8 @@ 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;
-    get cobuildRunnerId(): string | undefined;
-    executeAsync({ onStart, onResult }: {
-        onStart: (record: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
-        onResult: (record: OperationExecutionRecord) => Promise<void>;
-    }): Promise<void>;
+    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

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

@@ -16,8 +16,6 @@ export interface IOperationMetaData {
     durationInSeconds: number;
     logPath: string;
     errorLogPath: string;
-    cobuildContextId: string | undefined;
-    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the meta files of a operation.
@@ -40,7 +38,7 @@ export declare class OperationMetadataManager {
      * Example: `.rush/temp/operation/_phase_build/error.log`
      */
     get relativeFilepaths(): string[];
-    saveAsync({ durationInSeconds, cobuildContextId, cobuildRunnerId, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
+    saveAsync({ durationInSeconds, logPath, errorLogPath }: IOperationMetaData): Promise<void>;
     tryRestoreAsync({ terminal, logPath, errorLogPath }: {
         terminal: ITerminal;
         logPath: string;

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

@@ -10,8 +10,6 @@ export interface IOperationStateFileOptions {
  */
 export interface IOperationStateJson {
     nonCachedDurationMs: number;
-    cobuildContextId: string | undefined;
-    cobuildRunnerId: string | undefined;
 }
 /**
  * A helper class for managing the state file of a operation.

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

@@ -7,18 +7,10 @@ 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/ProjectLogWritable.d.ts

@@ -11,17 +11,6 @@ export declare class ProjectLogWritable extends TerminalWritable {
     private _logWriter;
     private _errorLogWriter;
     constructor(project: RushConfigurationProject, terminal: CollatedTerminal, logFilenameIdentifier: string);
-    static getLogFilePaths({ project, logFilenameIdentifier, isLegacyLog }: {
-        project: RushConfigurationProject;
-        logFilenameIdentifier: string;
-        isLegacyLog?: boolean;
-    }): {
-        logPath: string;
-        errorLogPath: string;
-        relativeLogPath: string;
-        relativeErrorLogPath: string;
-    };
-    writeChunk(chunk: ITerminalChunk): void;
     protected onWriteChunk(chunk: ITerminalChunk): void;
     protected onClose(): void;
 }

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

@@ -3,11 +3,20 @@ import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 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: {
+        [filePath: string]: string;
+    };
+    arguments: string;
+}
 export interface IOperationRunnerOptions {
     rushProject: RushConfigurationProject;
     rushConfiguration: RushConfiguration;
+    buildCacheConfiguration: BuildCacheConfiguration | undefined;
     commandToRun: string;
+    isIncrementalBuildAllowed: boolean;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     displayName: string;
     phase: IPhase;
@@ -23,18 +32,31 @@ export interface IOperationRunnerOptions {
  */
 export declare class ShellOperationRunner implements IOperationRunner {
     readonly name: string;
+    isCacheWriteAllowed: boolean;
+    isSkipAllowed: boolean;
     readonly reportTiming: boolean;
     readonly silent: boolean;
-    readonly cacheable: boolean;
     readonly warningsAreAllowed: boolean;
-    private readonly _commandToRun;
-    private readonly _logFilenameIdentifier;
     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>;
-    getConfigHash(): string;
     private _executeAsync;
+    private _tryGetProjectBuildCacheAsync;
 }
 /**
  * When running a command from the "scripts" block in package.json, if the command