@rushstack/rush-sdk 5.170.1-pr5378.0 → 5.171.0

package/lib-commonjs/{logic/operations → cli/parsing}/ParseParallelism.js

@@ -1,6 +1,5 @@
-const _m = require("../../../lib-shim/index.js")._rushSdk_loadInternalModule("logic/operations/ParseParallelism");
+const _m = require("../../../lib-shim/index.js")._rushSdk_loadInternalModule("cli/parsing/ParseParallelism");
 module.exports = _m;
-exports.coerceParallelism = _m.coerceParallelism;
 exports.getNumberOfCores = _m.getNumberOfCores;
 exports.parseParallelism = _m.parseParallelism;
 exports.parseParallelismPercent = _m.parseParallelismPercent;

package/lib-commonjs/index.js

@@ -25,7 +25,6 @@ exports.LockStepVersionPolicy = _m.LockStepVersionPolicy;
 exports.LookupByPath = _m.LookupByPath;
 exports.NpmOptionsConfiguration = _m.NpmOptionsConfiguration;
 exports.Operation = _m.Operation;
-exports.OperationGraphHooks = _m.OperationGraphHooks;
 exports.OperationStatus = _m.OperationStatus;
 exports.PackageJsonDependency = _m.PackageJsonDependency;
 exports.PackageJsonDependencyMeta = _m.PackageJsonDependencyMeta;

package/lib-commonjs/logic/operations/OperationExecutionManager.js

@@ -0,0 +1,3 @@
+const _m = require("../../../lib-shim/index.js")._rushSdk_loadInternalModule("logic/operations/OperationExecutionManager");
+module.exports = _m;
+exports.OperationExecutionManager = _m.OperationExecutionManager;

package/lib-commonjs/logic/operations/OperationStatus.js

@@ -1,5 +1,4 @@
 const _m = require("../../../lib-shim/index.js")._rushSdk_loadInternalModule("logic/operations/OperationStatus");
 module.exports = _m;
 exports.OperationStatus = _m.OperationStatus;
-exports.SUCCESS_STATUSES = _m.SUCCESS_STATUSES;
 exports.TERMINAL_STATUSES = _m.TERMINAL_STATUSES;

package/lib-commonjs/logic/operations/WeightedOperationPlugin.js

@@ -0,0 +1,3 @@
+const _m = require("../../../lib-shim/index.js")._rushSdk_loadInternalModule("logic/operations/WeightedOperationPlugin");
+module.exports = _m;
+exports.WeightedOperationPlugin = _m.WeightedOperationPlugin;

package/lib-dts/api/CommandLineConfiguration.d.ts

@@ -85,13 +85,6 @@ export interface IPhasedCommandConfig extends IPhasedCommandWithoutPhasesJson, I
      * How many milliseconds to wait after receiving a file system notification before executing in watch mode.
      */
     watchDebounceMs?: number;
-    /**
-     * If true, when running this command in watch mode the operation graph will include every project
-     * in the repository (respecting phase selection), but only the projects selected by the user's
-     * CLI project selection parameters will be initially enabled. Other projects will remain disabled
-     * unless they become required or are explicitly selected in a subsequent pass.
-     */
-    includeAllProjectsInWatchGraph?: boolean;
     /**
      * If set to `true`, then this phased command will always perform an install before executing, regardless of CLI flags.
      * If set to `false`, then Rush will define a built-in "--install" CLI flag for this command.

package/lib-dts/api/CommandLineJson.d.ts

@@ -46,7 +46,6 @@ export interface IPhasedCommandJson extends IPhasedCommandWithoutPhasesJson {
         alwaysWatch: boolean;
         debounceMs?: number;
         watchPhases: string[];
-        includeAllProjectsInWatchGraph?: boolean;
     };
     installOptions?: {
         alwaysInstall: boolean;

package/lib-dts/api/EventHooks.d.ts

@@ -1,6 +1,6 @@
 import type { IEventHooksJson } from './RushConfiguration';
 /**
- * Events happen during Rush invocation.
+ * Events happen during Rush runs.
  * @beta
  */
 export declare enum Event {

package/lib-dts/cli/parsing/ParseParallelism.d.ts

@@ -0,0 +1,17 @@
+export declare function getNumberOfCores(): number;
+/**
+ * Since the JSON value is a string, it must be a percentage like "50%",
+ * which we convert to a number based on the available parallelism.
+ * For example, if the available parallelism (not the -p flag) is 8 and the weight is "50%",
+ * then the resulting weight will be 4.
+ *
+ * @param weight
+ * @returns
+ */
+export declare function parseParallelismPercent(weight: string, numberOfCores?: number): number;
+/**
+ * Parses a command line specification for desired parallelism.
+ * Factored out to enable unit tests
+ */
+export declare function parseParallelism(rawParallelism: string | undefined, numberOfCores?: number): number;
+//# sourceMappingURL=ParseParallelism.d.ts.map

package/lib-dts/cli/parsing/SelectionParameterSet.d.ts

@@ -46,7 +46,7 @@ export declare class SelectionParameterSet {
      *
      * If no parameters are specified, returns all projects in the Rush config file.
      */
-    getSelectedProjectsAsync(terminal: ITerminal, allowEmptySelection?: boolean): Promise<Set<RushConfigurationProject>>;
+    getSelectedProjectsAsync(terminal: ITerminal): Promise<Set<RushConfigurationProject>>;
     /**
      * Represents the selection as `--filter` parameters to pnpm.
      *

package/lib-dts/cli/scriptActions/PhasedScriptAction.d.ts

@@ -13,7 +13,6 @@ export interface IPhasedScriptActionOptions extends IBaseScriptActionOptions<IPh
     originalPhases: Set<IPhase>;
     initialPhases: Set<IPhase>;
     watchPhases: Set<IPhase>;
-    includeAllProjectsInWatchGraph: boolean;
     phases: Map<string, IPhase>;
     alwaysWatch: boolean;
     alwaysInstall: boolean | undefined;
@@ -45,9 +44,10 @@ export declare class PhasedScriptAction extends BaseScriptAction<IPhasedCommandC
     private readonly _watchDebounceMs;
     private readonly _alwaysWatch;
     private readonly _alwaysInstall;
-    private readonly _includeAllProjectsInWatchGraph;
     private readonly _knownPhases;
     private readonly _terminal;
+    private _changedProjectsOnly;
+    private _executionAbortController;
     private readonly _changedProjectsOnlyParameter;
     private readonly _selectionParameters;
     private readonly _verboseParameter;
@@ -64,6 +64,16 @@ export declare class PhasedScriptAction extends BaseScriptAction<IPhasedCommandC
     private readonly _includePhaseDeps;
     constructor(options: IPhasedScriptActionOptions);
     runAsync(): Promise<void>;
+    private _runInitialPhasesAsync;
+    private _registerWatchModeInterface;
+    /**
+     * Runs the command in watch mode. Fundamentally is a simple loop:
+     * 1) Wait for a change to one or more projects in the selection
+     * 2) Invoke the command on the changed projects, and, if applicable, impacted projects
+     *    Uses the same algorithm as --impacted-by
+     * 3) Goto (1)
+     */
+    private _runWatchPhasesAsync;
     /**
      * Runs a set of operations and reports the results.
      */

package/lib-dts/index.d.ts

@@ -40,17 +40,14 @@ export { ExperimentsConfiguration, type IExperimentsJson } from './api/Experimen
 export { CustomTipsConfiguration, CustomTipId, type ICustomTipsJson, type ICustomTipInfo, type ICustomTipItemJson, CustomTipSeverity, CustomTipType } from './api/CustomTipsConfiguration';
 export { ProjectChangeAnalyzer, type IGetChangedProjectsOptions } from './logic/ProjectChangeAnalyzer';
 export type { IInputsSnapshot, GetInputsSnapshotAsyncFn as GetInputsSnapshotAsyncFn, IRushConfigurationProjectForSnapshot } from './logic/incremental/InputsSnapshot';
-export type { IOperationRunner, IOperationRunnerContext, IOperationLastState } from './logic/operations/IOperationRunner';
-export type { IConfigurableOperation, IBaseOperationExecutionResult, IExecutionResult, IOperationExecutionResult, IOperationStateHashComponents } from './logic/operations/IOperationExecutionResult';
-export { type IOperationOptions, type OperationEnabledState, Operation } from './logic/operations/Operation';
-export { type IParallelismScalar, type Parallelism } from './logic/operations/ParseParallelism';
+export type { IOperationRunner, IOperationRunnerContext } from './logic/operations/IOperationRunner';
+export type { IExecutionResult, IOperationExecutionResult } from './logic/operations/IOperationExecutionResult';
+export { type IOperationOptions, Operation } from './logic/operations/Operation';
 export { OperationStatus } from './logic/operations/OperationStatus';
 export type { ILogFilePaths } from './logic/operations/ProjectLogWritable';
 export { RushSession, type IRushSessionOptions, type CloudBuildCacheProviderFactory, type CobuildLockProviderFactory } from './pluginFramework/RushSession';
 export { type IRushCommand, type IGlobalCommand, type IPhasedCommand, RushLifecycleHooks } from './pluginFramework/RushLifeCycle';
-export { type ICreateOperationsContext, type IOperationGraphContext, type IPhasedCommandPlugin, PhasedCommandHooks } from './pluginFramework/PhasedCommandHooks';
-export type { IOperationGraph, IOperationGraphIterationOptions } from './logic/operations/IOperationGraph';
-export { OperationGraphHooks } from './pluginFramework/OperationGraphHooks';
+export { type ICreateOperationsContext, type IExecuteOperationsContext, PhasedCommandHooks } from './pluginFramework/PhasedCommandHooks';
 export type { IRushPlugin } from './pluginFramework/IRushPlugin';
 export type { IBuiltInPluginConfiguration as _IBuiltInPluginConfiguration } from './pluginFramework/PluginLoader/BuiltInPluginLoader';
 export type { IRushPluginConfigurationBase as _IRushPluginConfigurationBase } from './api/RushPluginsConfiguration';

package/lib-dts/logic/ProjectWatcher.d.ts

@@ -1,15 +1,15 @@
 import { type ITerminal } from '@rushstack/terminal';
-import type { IInputsSnapshot } from './incremental/InputsSnapshot';
+import type { IInputsSnapshot, GetInputsSnapshotAsyncFn } from './incremental/InputsSnapshot';
 import type { RushConfiguration } from '../api/RushConfiguration';
 import type { RushConfigurationProject } from '../api/RushConfigurationProject';
-import type { IOperationGraph } from './operations/IOperationGraph';
 export interface IProjectWatcherOptions {
-    graph: IOperationGraph;
-    debounceMs: number;
+    abortSignal: AbortSignal;
+    getInputsSnapshotAsync: GetInputsSnapshotAsyncFn;
+    debounceMs?: number;
     rushConfiguration: RushConfiguration;
+    projectsToWatch: ReadonlySet<RushConfigurationProject>;
     terminal: ITerminal;
-    /** Initial inputs snapshot; required so watcher can enumerate nested folders immediately */
-    initialSnapshot: IInputsSnapshot;
+    initialSnapshot?: IInputsSnapshot | undefined;
 }
 export interface IProjectChangeResult {
     /**
@@ -25,81 +25,59 @@ export interface IPromptGeneratorFunction {
     (isPaused: boolean): Iterable<string>;
 }
 /**
- * Watches a set of projects in the repository for file changes and triggers
- * rebuild iterations on the operation graph.
+ * This class is for incrementally watching a set of projects in the repository for changes.
  *
- * Uses `fs.watch()` rather than `chokidar` because only a boolean "something changed"
- * signal is needed; actual change detection is deferred to `getInputsSnapshotAsync`.
+ * We are manually using fs.watch() instead of `chokidar` because all we want from the file system watcher is a boolean
+ * signal indicating that "at least 1 file in a watched project changed". We then defer to getInputsSnapshotAsync (which
+ * is responsible for change detection in all incremental builds) to determine what actually chanaged.
+ *
+ * Calling `waitForChange()` will return a promise that resolves when the package-deps of one or
+ * more projects differ from the value the previous time it was invoked. The first time will always resolve with the full selection.
  */
 export declare class ProjectWatcher {
+    private readonly _abortSignal;
+    private readonly _getInputsSnapshotAsync;
     private readonly _debounceMs;
+    private readonly _repoRoot;
     private readonly _rushConfiguration;
+    private readonly _projectsToWatch;
     private readonly _terminal;
-    private readonly _graph;
-    private _repoRoot;
-    private _watchers;
-    private _closePromises;
-    private _debounceHandle;
-    private _isWatching;
+    private _initialSnapshot;
+    private _previousSnapshot;
+    private _forceChangedProjects;
+    private _resolveIfChanged;
+    private _onAbort;
+    private _getPromptLines;
     private _lastStatus;
     private _renderedStatusLines;
-    private _lastSnapshot;
-    private _stdinListening;
-    private _stdinHadRawMode;
-    private _onStdinDataBound;
+    isPaused: boolean;
     constructor(options: IProjectWatcherOptions);
-    /**
-     * Resets the rendered line count so the next status update does not attempt
-     * to overwrite previously rendered lines.
-     */
+    pause(): void;
+    resume(): void;
+    invalidateProject(project: RushConfigurationProject, reason: string): boolean;
+    invalidateAll(reason: string): void;
     clearStatus(): void;
-    /**
-     * Re-renders the most recent status line (or a default) in place.
-     */
     rerenderStatus(): void;
+    setPromptGenerator(promptGenerator: IPromptGeneratorFunction): void;
     /**
-     * Renders the given status message to the terminal, preceded by mode indicators
-     * and keybind help when stdin is active. Overwrites previously rendered status lines
-     * when not mid-execution.
+     * Waits for a change to the package-deps of one or more of the selected projects, since the previous invocation.
+     * Will return immediately the first time it is invoked, since no state has been recorded.
+     * If no change is currently present, watches the source tree of all selected projects for file changes.
+     * `waitForChange` is not allowed to be called multiple times concurrently.
      */
+    waitForChangeAsync(onWatchingFiles?: () => void): Promise<IProjectChangeResult>;
     private _setStatus;
     /**
-     * Begins watching the file system for changes in all tracked project folders.
-     * On platforms without native recursive watch support (Linux), enumerates nested
-     * folders from the last snapshot to set up individual watchers.
-     */
-    private _startWatching;
-    /**
-     * Closes all active file system watchers and waits for their close events to settle.
-     */
-    private _stopWatchingAsync;
-    /**
-     * Handles a raw file system event by debouncing and scheduling an iteration.
-     * Ignores changes to `.git` and `node_modules`.
-     */
-    private _onFsEvent;
-    /**
-     * Schedules a new execution iteration on the graph in response to detected file changes.
-     */
-    private _scheduleIteration;
-    /**
-     * Sets up a raw-mode stdin listener so the user can interact with the watch session
-     * via single-key keybinds. Captures the previous raw-mode state for restoration on dispose.
-     */
-    private _ensureStdin;
-    /**
-     * Removes the stdin listener and restores the previous raw-mode state.
-     */
-    private _disposeStdin;
-    /**
-     * Processes a chunk of stdin data, dispatching each character to the appropriate
-     * keybind action on the operation graph.
+     * Determines which, if any, projects (within the selection) have new hashes for files that are not in .gitignore
      */
-    private _onStdinData;
+    private _computeChangedAsync;
+    private _commitChanges;
     /**
-     * Adjusts the parallelism on the operation graph by the given delta
-     * and reports the result.
+     * Tests for inequality of the passed Maps. Order invariant.
+     *
+     * @returns `true` if the maps are different, `false` otherwise
      */
-    private _adjustParallelism;
+    private static _haveProjectDepsChanged;
+    private static _enumeratePathsToWatch;
 }
 //# sourceMappingURL=ProjectWatcher.d.ts.map

package/lib-dts/logic/buildCache/OperationBuildCache.d.ts

@@ -1,7 +1,7 @@
 import type { ITerminal } from '@rushstack/terminal';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
-import type { IBaseOperationExecutionResult } from '../operations/IOperationExecutionResult';
+import type { IOperationExecutionResult } from '../operations/IOperationExecutionResult';
 /**
  * @internal
  */
@@ -58,7 +58,7 @@ export declare class OperationBuildCache {
     private static _tryGetTarUtility;
     get cacheId(): string | undefined;
     static getOperationBuildCache(options: IProjectBuildCacheOptions): OperationBuildCache;
-    static forOperation(executionResult: IBaseOperationExecutionResult, options: IOperationBuildCacheOptions): OperationBuildCache;
+    static forOperation(executionResult: IOperationExecutionResult, options: IOperationBuildCacheOptions): OperationBuildCache;
     tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     /**

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

@@ -1,68 +1,17 @@
 import type { StdioSummarizer, IProblemCollector } from '@rushstack/terminal';
 import type { OperationStatus } from './OperationStatus';
-import type { IOperationLastState } from './IOperationRunner';
 import type { Operation } from './Operation';
 import type { IStopwatchResult } from '../../utilities/Stopwatch';
 import type { ILogFilePaths } from './ProjectLogWritable';
 /**
- * Structured components of the state hash for an operation.
- * @alpha
- */
-export interface IOperationStateHashComponents {
-    /**
-     * The state hashes of operation dependencies, sorted by name.
-     * Each entry is of the form `{dependencyName}={hash}`.
-     */
-    readonly dependencies: readonly string[];
-    /**
-     * The hash of the operation's own local inputs (e.g. tracked files, environment variables).
-     */
-    readonly local: string;
-    /**
-     * The hash of the operation's configuration (e.g. CLI parameters).
-     */
-    readonly config: string;
-}
-/**
+ * The `IOperationExecutionResult` interface represents the results of executing an {@link Operation}.
  * @alpha
  */
-export interface IBaseOperationExecutionResult {
+export interface IOperationExecutionResult {
     /**
      * The operation itself
      */
     readonly operation: Operation;
-    /**
-     * The relative path to the folder that contains operation metadata. This folder will be automatically included in cache entries.
-     */
-    readonly metadataFolderPath: string;
-    /**
-     * Gets the hash of the state of all registered inputs to this operation.
-     * Calling this method will throw if Git is not available.
-     */
-    getStateHash(): string;
-    /**
-     * Gets the structured components of the state hash. This is useful for debugging and
-     * incremental change detection.
-     * Calling this method will throw if Git is not available.
-     */
-    getStateHashComponents(): IOperationStateHashComponents;
-}
-/**
- * The `IConfigurableOperation` interface represents an {@link Operation} whose
- * execution can be configured before running.
- * @alpha
- */
-export interface IConfigurableOperation extends IBaseOperationExecutionResult {
-    /**
-     * True if the operation should execute in this iteration, false otherwise.
-     */
-    enabled: boolean;
-}
-/**
- * The `IOperationExecutionResult` interface represents the results of executing an {@link Operation}.
- * @alpha
- */
-export interface IOperationExecutionResult extends IBaseOperationExecutionResult, IOperationLastState {
     /**
      * 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
@@ -79,10 +28,6 @@ export interface IOperationExecutionResult extends IBaseOperationExecutionResult
      * If this operation is only present in the graph to maintain dependency relationships, this flag will be set to true.
      */
     readonly silent: boolean;
-    /**
-     * True if the operation should execute in this iteration, false otherwise.
-     */
-    readonly enabled: boolean;
     /**
      * Object tracking execution timing.
      */
@@ -99,10 +44,24 @@ export interface IOperationExecutionResult extends IBaseOperationExecutionResult
      * The value indicates the duration of the same operation without cache hit.
      */
     readonly nonCachedDurationMs: number | undefined;
+    /**
+     * The relative path to the folder that contains operation metadata. This folder will be automatically included in cache entries.
+     */
+    readonly metadataFolderPath: string | undefined;
     /**
      * The paths to the log files, if applicable.
      */
     readonly logFilePaths: ILogFilePaths | undefined;
+    /**
+     * Gets the hash of the state of all registered inputs to this operation.
+     * Calling this method will throw if Git is not available.
+     */
+    getStateHash(): string;
+    /**
+     * Gets the components of the state hash. This is useful for debugging purposes.
+     * Calling this method will throw if Git is not available.
+     */
+    getStateHashComponents(): ReadonlyArray<string>;
 }
 /**
  * The `IExecutionResult` interface represents the results of executing a set of {@link Operation}s.

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

@@ -4,17 +4,6 @@ import type { OperationStatus } from './OperationStatus';
 import type { OperationMetadataManager } from './OperationMetadataManager';
 import type { IStopwatchResult } from '../../utilities/Stopwatch';
 import type { IEnvironment } from '../../utilities/Utilities';
-/**
- * A snapshot of a previous operation execution, passed to runners to inform incremental behavior.
- *
- * @beta
- */
-export interface IOperationLastState {
-    /**
-     * The status from the previous execution of this operation.
-     */
-    readonly status: OperationStatus;
-}
 /**
  * Information passed to the executing `IOperationRunner`
  *
@@ -60,12 +49,6 @@ export interface IOperationRunnerContext {
      * it later (for example to re-print errors at end of execution).
      */
     error?: Error;
-    /**
-     * Returns a callback that invalidates this operation so that it will be re-executed in the next iteration.
-     * The returned callback captures only the minimal state needed, avoiding retention of the full context.
-     * Callers should store the result rather than calling this method repeatedly.
-     */
-    getInvalidateCallback(): (reason: string) => void;
     /**
      * Invokes the specified callback with a terminal that is associated with this operation.
      *
@@ -78,7 +61,7 @@ export interface IOperationRunnerContext {
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
- * `OperationGraph`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
+ * `OperationExecutionManager`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
  * implementation manages the actual process for running a single operation.
  *
  * @beta
@@ -110,26 +93,13 @@ export interface IOperationRunner {
      * analysis purposes.
      */
     readonly isNoOp?: boolean;
-    /**
-     * If true, this runner currently owns some kind of active resource (e.g. a service or a watch process).
-     * This can be used to determine if the operation is "in progress" even if it is not currently executing.
-     * If the runner supports this property, it should update it as appropriate during execution.
-     * The property is optional to avoid breaking existing implementations of IOperationRunner.
-     */
-    readonly isActive?: boolean;
     /**
      * Method to be executed for the operation.
-     * @param context - The context object containing information about the execution environment.
-     * @param lastState - The last execution result of this operation, if any.
      */
-    executeAsync(context: IOperationRunnerContext, lastState?: IOperationLastState): Promise<OperationStatus>;
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     /**
      * Return a hash of the configuration that affects the operation.
      */
     getConfigHash(): string;
-    /**
-     * If this runner performs any background work to optimize future runs, this method will clean it up.
-     */
-    closeAsync?(): Promise<void>;
 }
 //# sourceMappingURL=IOperationRunner.d.ts.map

package/lib-dts/logic/operations/IPCOperationRunner.d.ts

@@ -1,15 +1,16 @@
+import type { OperationRequestRunCallback } from '@rushstack/operation-graph';
 import type { IPhase } from '../../api/CommandLineConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
-import type { IOperationRunner, IOperationRunnerContext, IOperationLastState } from './IOperationRunner';
+import type { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 import { OperationStatus } from './OperationStatus';
 export interface IIPCOperationRunnerOptions {
     phase: IPhase;
     project: RushConfigurationProject;
     name: string;
-    initialCommand: string;
-    incrementalCommand: string | undefined;
+    commandToRun: string;
     commandForHash: string;
     persist: boolean;
+    requestRun: OperationRequestRunCallback;
     ignoredParameterValues: ReadonlyArray<string>;
 }
 /**
@@ -22,17 +23,16 @@ export declare class IPCOperationRunner implements IOperationRunner {
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
     private readonly _rushProject;
-    private readonly _initialCommand;
-    private readonly _incrementalCommand;
+    private readonly _commandToRun;
     private readonly _commandForHash;
     private readonly _persist;
+    private readonly _requestRun;
     private readonly _ignoredParameterValues;
     private _ipcProcess;
     private _processReadyPromise;
     constructor(options: IIPCOperationRunnerOptions);
-    get isActive(): boolean;
-    executeAsync(context: IOperationRunnerContext, lastState?: IOperationLastState): Promise<OperationStatus>;
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     getConfigHash(): string;
-    closeAsync(): Promise<void>;
+    shutdownAsync(): Promise<void>;
 }
 //# sourceMappingURL=IPCOperationRunner.d.ts.map

package/lib-dts/logic/operations/Operation.d.ts

@@ -2,18 +2,6 @@ import type { RushConfigurationProject } from '../../api/RushConfigurationProjec
 import type { IPhase } from '../../api/CommandLineConfiguration';
 import type { IOperationRunner } from './IOperationRunner';
 import type { IOperationSettings } from '../../api/RushProjectConfiguration';
-import { type Parallelism } from './ParseParallelism';
-/**
- * State for the `enabled` property of an `Operation`.
- *
- * - `true`: The operation should be executed if it or any dependencies changed.
- * - `false`: The operation should be skipped.
- * - `"ignore-dependency-changes"`: The operation should be executed if there are local changes in the project,
- *   otherwise it should be skipped. This is useful for operations like "test" where you may want to skip
- *   testing projects that haven't changed.
- * @alpha
- */
-export type OperationEnabledState = boolean | 'ignore-dependency-changes';
 /**
  * Options for constructing a new Operation.
  * @alpha
@@ -27,18 +15,6 @@ export interface IOperationOptions {
      * The Rush project associated with this Operation
      */
     project: RushConfigurationProject;
-    /**
-     * If set to false, this operation will be skipped during evaluation (return OperationStatus.Skipped).
-     * This is useful for plugins to alter the scope of the operation graph across executions,
-     * e.g. to enable or disable unit test execution, or to include or exclude dependencies.
-     *
-     * The special value "ignore-dependency-changes" can be used to indicate that this operation should only
-     * be executed if there are local changes in the project. This is useful for operations like
-     * "test" where you may want to skip testing projects that haven't changed.
-     *
-     * The default value is `true`, meaning the operation will be executed if it or any dependencies change.
-     */
-    enabled?: OperationEnabledState;
     /**
      * When the scheduler is ready to process this `Operation`, the `runner` implements the actual work of
      * running the operation.
@@ -55,7 +31,7 @@ export interface IOperationOptions {
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
- * `OperationGraph`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
+ * `OperationExecutionManager`. Each `Operation` has a `runner` member of type `IOperationRunner`, whose
  * implementation manages the actual process of running a single operation.
  *
  * The graph of `Operation` instances will be cloned into a separate execution graph after processing.
@@ -91,23 +67,17 @@ export declare class Operation {
      */
     runner: IOperationRunner | undefined;
     /**
-     * The concurrency weight for this operation. When coerced to an integer via `coerceParallelism`,
-     * this value represents how many concurrency slots the operation consumes while running.
-     *
-     * May be specified as:
-     * - A raw `number`: used directly as the slot count (e.g. `2` consumes two slots).
-     * - An `IParallelismScalar` (e.g. `{ scalar: 0.5 }`): coerced relative to the graph's
-     *   configured `maxParallelism` at execution time, so the weight scales with the available
-     *   concurrency rather than being fixed at parse time.
-     *
-     * Coerced values guide scheduling as follows:
-     * - `1` slot: typical operation consuming one logical thread.
-     * - `> 1` slots: operation that spawns multiple threads or requires significant RAM; reserving
-     *   extra slots prevents overloading the machine (e.g. a whole-program bundler or a test suite
-     *   that runs its own internal parallelism).
-     * - `0` slots: effectively free (e.g. a no-op or cache-restore step).
-     */
-    weight: Parallelism;
+     * The weight for this operation. This scalar is the contribution of this operation to the
+     * `criticalPathLength` calculation above. Modify to indicate the following:
+     * - `weight` === 1: indicates that this operation has an average duration
+     * - `weight` > 1: indicates that this operation takes longer than average and so the scheduler
+     *     should try to favor starting it over other, shorter operations. An example might be an operation that
+     *     bundles an entire application and runs whole-program optimization.
+     * - `weight` < 1: indicates that this operation takes less time than average and so the scheduler
+     *     should favor other, longer operations over it. An example might be an operation to unpack a cached
+     *     output, or an operation using NullOperationRunner, which might use a value of 0.
+     */
+    weight: number;
     /**
      * Get the operation settings for this operation, defaults to the values defined in
      *  the project configuration.
@@ -117,14 +87,8 @@ export declare class Operation {
      * If set to false, this operation will be skipped during evaluation (return OperationStatus.Skipped).
      * This is useful for plugins to alter the scope of the operation graph across executions,
      * e.g. to enable or disable unit test execution, or to include or exclude dependencies.
-     *
-     * The special value "ignore-dependency-changes" can be used to indicate that this operation should only
-     * be executed if there are local changes in the project. This is useful for operations like
-     * "test" where you may want to skip testing projects that haven't changed.
-     *
-     * The default value is `true`, meaning the operation will be executed if it or any dependencies change.
-     */
-    enabled: OperationEnabledState;
+     */
+    enabled: boolean;
     constructor(options: IOperationOptions);
     /**
      * The name of this operation, for logging.