@rushstack/rush-sdk 5.103.0 → 5.104.0

package/dist/rush-lib.d.ts

@@ -6,6 +6,7 @@
 /// <reference types="node" />
 
 import { AsyncParallelHook } from 'tapable';
+import { AsyncSeriesBailHook } from 'tapable';
 import { AsyncSeriesHook } from 'tapable';
 import { AsyncSeriesWaterfallHook } from 'tapable';
 import type { CollatedWriter } from '@rushstack/stream-collator';
@@ -209,6 +210,62 @@ export declare class ChangeManager {
  */
 export declare type CloudBuildCacheProviderFactory = (buildCacheJson: IBuildCacheJson) => ICloudBuildCacheProvider | Promise<ICloudBuildCacheProvider>;
 
+/**
+ * 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 cobuildFeatureEnabled: 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;
+}
+
+/**
+ * @beta
+ */
+export declare type CobuildLockProviderFactory = (cobuildJson: ICobuildJson) => ICobuildLockProvider | Promise<ICobuildLockProvider>;
+
 /**
  * Use this class to load and save the "common/config/rush/common-versions.json" config file.
  * This config file stores dependency version information that affects all projects in the repo.
@@ -390,6 +447,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;
     /**
@@ -445,6 +505,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}
@@ -602,6 +677,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.
      */
@@ -765,6 +867,114 @@ export declare interface ICloudBuildCacheProvider {
     deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void>;
 }
 
+/**
+ * @beta
+ */
+export declare 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 declare 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 declare interface ICobuildJson {
+    cobuildFeatureEnabled: boolean;
+    cobuildLockProvider: string;
+}
+
+/**
+ * @beta
+ */
+export declare 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>;
+}
+
 /**
  * A collection of environment variables
  * @public
@@ -802,6 +1012,10 @@ export declare interface ICreateOperationsContext {
      * The configuration for the build cache, if the feature is enabled.
      */
     readonly buildCacheConfiguration: BuildCacheConfiguration | undefined;
+    /**
+     * The configuration for the cobuild, if cobuild feature and build cache feature are both enabled.
+     */
+    readonly cobuildConfiguration: CobuildConfiguration | undefined;
     /**
      * The set of custom parameters for the executing command.
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
@@ -837,6 +1051,10 @@ export declare interface ICreateOperationsContext {
      * The set of Rush projects selected for the current command execution.
      */
     readonly projectSelection: ReadonlySet<RushConfigurationProject>;
+    /**
+     * All successfully loaded rush-project.json data for selected projects.
+     */
+    readonly projectConfigurations: ReadonlyMap<RushConfigurationProject, RushProjectConfiguration>;
     /**
      * The set of Rush projects that have not been built in the current process since they were last modified.
      * When `isInitial` is true, this will be an exact match of `projectSelection`.
@@ -1182,6 +1400,10 @@ export declare interface _INpmOptionsJson extends IPackageManagerOptionsJsonBase
  * @alpha
  */
 export declare 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
@@ -1206,6 +1428,10 @@ export declare 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;
 }
 
 /**
@@ -1215,6 +1441,8 @@ export declare interface _IOperationMetadata {
     durationInSeconds: number;
     logPath: string;
     errorLogPath: string;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 
 /**
@@ -1258,9 +1486,9 @@ export declare 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.
      */
@@ -1274,14 +1502,14 @@ export declare 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;
 }
 
 /**
@@ -1316,6 +1544,73 @@ export declare 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;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IOperationSettings {
+    /**
+     * The name of the operation. This should be a key in the `package.json`'s `scripts` object.
+     */
+    operationName: string;
+    /**
+     * Specify the folders where this operation writes its output files. If enabled, the Rush build
+     * cache will restore these folders from the cache. The strings are folder names under the project
+     * root folder.
+     *
+     * These folders should not be tracked by Git. They must not contain symlinks.
+     */
+    outputFolderNames?: string[];
+    /**
+     * Disable caching for this operation. The operation will never be restored from cache.
+     * This may be useful if this operation affects state outside of its folder.
+     *
+     * This option is only used when the build cache is enabled for the repo. You can set
+     * disableBuildCacheForOperation=true to disable caching for a specific project operation.
+     * This is a useful workaround if that project's build scripts violate the assumptions of the cache,
+     * for example by writing files outside the project folder. Where possible, a better solution is to improve
+     * the build scripts to be compatible with caching.
+     */
+    disableBuildCacheForOperation?: boolean;
+    /**
+     * An optional list of environment variables that can affect this operation. The values of
+     * these environment variables will become part of the hash when reading and writing the build cache.
+     *
+     * Note: generally speaking, all environment variables available to Rush are also available to any
+     * operations performed -- Rush assumes that environment variables do not affect build outputs unless
+     * you list them here.
+     */
+    dependsOnEnvVars?: string[];
+    /**
+     * An optional list of glob (minimatch) patterns pointing to files that can affect this operation.
+     * The hash values of the contents of these files will become part of the final hash when reading
+     * and writing the build cache.
+     *
+     * Note: if a particular file will be matched by patterns provided by both `incrementalBuildIgnoredGlobs` and
+     * `dependsOnAdditionalFiles` options - `dependsOnAdditionalFiles` will win and the file will be included
+     * calculating final hash value when reading and writing the build cache
+     */
+    dependsOnAdditionalFiles?: string[];
 }
 
 /**
@@ -1331,6 +1626,8 @@ export declare interface _IOperationStateFileOptions {
  */
 export declare interface _IOperationStateJson {
     nonCachedDurationMs: number;
+    cobuildContextId: string | undefined;
+    cobuildRunnerId: string | undefined;
 }
 
 /**
@@ -1499,7 +1796,7 @@ export declare interface IPrefixMatch<TItem> {
 /**
  * @internal
  */
-declare interface IRawRepoState {
+export declare interface _IRawRepoState {
     projectState: Map<RushConfigurationProject, Map<string, string>> | undefined;
     rootDir: string;
     rawHashes: Map<string, string>;
@@ -1620,6 +1917,33 @@ declare interface IRushPluginsConfigurationJson {
     plugins: IRushPluginConfiguration[];
 }
 
+/**
+ * Describes the file structure for the `<project root>/config/rush-project.json` config file.
+ * @internal
+ */
+export declare interface _IRushProjectJson {
+    /**
+     * The incremental analyzer can skip Rush commands for projects whose input files have
+     * not changed since the last build. Normally, every Git-tracked file under the project
+     * folder is assumed to be an input. Set incrementalBuildIgnoredGlobs to ignore specific
+     * files, specified as globs relative to the project folder. The list of file globs will
+     * be interpreted the same way your .gitignore file is.
+     */
+    incrementalBuildIgnoredGlobs?: string[];
+    /**
+     * Disable caching for this project. The project will never be restored from cache.
+     * This may be useful if this project affects state outside of its folder.
+     *
+     * This option is only used when the build cache is enabled for the repo. You can set
+     * disableBuildCacheForProject=true to disable caching for a specific project. This is a useful workaround
+     * if that project's build scripts violate the assumptions of the cache, for example by writing
+     * files outside the project folder. Where possible, a better solution is to improve the build scripts
+     * to be compatible with caching.
+     */
+    disableBuildCacheForProject?: boolean;
+    operationSettings?: IOperationSettings[];
+}
+
 declare type IRushRepositoryJson = IRushRepositoryJsonSingleUrl | IRushRepositoryJsonMultipleUrls;
 
 /**
@@ -2153,7 +2477,7 @@ export declare class _OperationMetadataManager {
      * Example: `.rush/temp/operation/_phase_build/error.log`
      */
     get relativeFilepaths(): string[];
-    saveAsync({ durationInSeconds, logPath, errorLogPath }: _IOperationMetadata): Promise<void>;
+    saveAsync({ durationInSeconds, cobuildContextId, cobuildRunnerId, logPath, errorLogPath }: _IOperationMetadata): Promise<void>;
     tryRestoreAsync({ terminal, logPath, errorLogPath }: {
         terminal: ITerminal;
         logPath: string;
@@ -2196,10 +2520,18 @@ export declare enum OperationStatus {
      * The Operation is on the queue, ready to execute (but may be waiting for dependencies)
      */
     Ready = "READY",
+    /**
+     * The Operation is Queued
+     */
+    Queued = "QUEUED",
     /**
      * The Operation is currently executing
      */
     Executing = "EXECUTING",
+    /**
+     * The Operation is currently executing by a remote process
+     */
+    RemoteExecuting = "REMOTE EXECUTING",
     /**
      * The Operation completed successfully and did not write to standard output
      */
@@ -2357,7 +2689,10 @@ export declare class PhasedCommandHooks {
      * Hook invoked before operation start
      * Hook is series for stable output.
      */
-    readonly beforeExecuteOperations: AsyncSeriesHook<[Map<Operation, IOperationExecutionResult>]>;
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+    Map<Operation, IOperationExecutionResult>,
+    ICreateOperationsContext
+    ]>;
     /**
      * Hook invoked when operation status changed
      * Hook is series for stable output.
@@ -2369,6 +2704,18 @@ export declare class PhasedCommandHooks {
      * Hook is series for stable output.
      */
     readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesBailHook<[
+    IOperationRunnerContext & IOperationExecutionResult
+    ], OperationStatus | undefined>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[
+    IOperationRunnerContext & IOperationExecutionResult
+    ]>;
     /**
      * Hook invoked after a run has finished and the command is watching for changes.
      * May be used to display additional relevant data to the user.
@@ -2581,7 +2928,7 @@ export declare class ProjectChangeAnalyzer {
     /**
      * @internal
      */
-    _ensureInitializedAsync(terminal: ITerminal): Promise<IRawRepoState | undefined>;
+    _ensureInitializedAsync(terminal: ITerminal): Promise<_IRawRepoState | undefined>;
     /**
      * The project state hash is calculated in the following way:
      * - Project dependencies are collected (see ProjectChangeAnalyzer.getPackageDeps)
@@ -3528,6 +3875,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.
      */
@@ -3691,18 +4042,76 @@ declare class RushPluginsConfiguration {
     constructor(jsonFilename: string);
 }
 
+/**
+ * Use this class to load the "config/rush-project.json" config file.
+ *
+ * This file provides project-specific configuration options.
+ * @alpha
+ */
+export declare class RushProjectConfiguration {
+    private static readonly _configCache;
+    readonly project: RushConfigurationProject;
+    /**
+     * {@inheritdoc _IRushProjectJson.incrementalBuildIgnoredGlobs}
+     */
+    readonly incrementalBuildIgnoredGlobs: ReadonlyArray<string>;
+    /**
+     * {@inheritdoc _IRushProjectJson.disableBuildCacheForProject}
+     */
+    readonly disableBuildCacheForProject: boolean;
+    readonly operationSettingsByOperationName: ReadonlyMap<string, Readonly<IOperationSettings>>;
+    private readonly _validationCache;
+    private constructor();
+    /**
+     * Validates that the requested phases are compatible.
+     * Deferral of this logic to its own method means that Rush no longer eagerly validates
+     * all defined commands in command-line.json. As such, while validation will be run for a given
+     * command upon invoking that command, defining overlapping phases in "rush custom-command"
+     * 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.
+     */
+    static tryLoadForProjectAsync(project: RushConfigurationProject, terminal: ITerminal): Promise<RushProjectConfiguration | undefined>;
+    /**
+     * Load only the `incrementalBuildIgnoredGlobs` property from the rush-project.json file, skipping
+     * validation of other parts of the config file.
+     *
+     * @remarks
+     * This function exists to allow the ProjectChangeAnalyzer to load just the ignore globs without
+     * 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;
+}
+
 /**
  * @beta
  */
 export declare class RushSession {
     private readonly _options;
     private readonly _cloudBuildCacheProviderFactories;
+    private readonly _cobuildLockProviderFactories;
     readonly hooks: RushLifecycleHooks;
     constructor(options: IRushSessionOptions);
     getLogger(name: string): ILogger;
     get terminalProvider(): ITerminalProvider;
     registerCloudBuildCacheProviderFactory(cacheProviderName: string, factory: CloudBuildCacheProviderFactory): void;
     getCloudBuildCacheProviderFactory(cacheProviderName: string): CloudBuildCacheProviderFactory | undefined;
+    registerCobuildLockProviderFactory(cobuildLockProviderName: string, factory: CobuildLockProviderFactory): void;
+    getCobuildLockProviderFactory(cobuildLockProviderName: string): CobuildLockProviderFactory | undefined;
 }
 
 /**

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 {
+    cobuildFeatureEnabled: 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 cobuildFeatureEnabled: 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");