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

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

@@ -0,0 +1,60 @@
+import { type TerminalWritable } from '@rushstack/terminal';
+import type { Operation } from './Operation';
+import { OperationStatus } from './OperationStatus';
+import { OperationExecutionRecord } from './OperationExecutionRecord';
+import type { IExecutionResult } from './IOperationExecutionResult';
+import type { IEnvironment } from '../../utilities/Utilities';
+import type { IInputsSnapshot } from '../incremental/InputsSnapshot';
+export interface IOperationExecutionManagerOptions {
+    quietMode: boolean;
+    debugMode: boolean;
+    parallelism: number;
+    allowOversubscription: boolean;
+    inputsSnapshot?: IInputsSnapshot;
+    destination?: TerminalWritable;
+    beforeExecuteOperationAsync?: (operation: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
+    afterExecuteOperationAsync?: (operation: OperationExecutionRecord) => Promise<void>;
+    createEnvironmentForOperation?: (operation: OperationExecutionRecord) => IEnvironment;
+    onOperationStatusChangedAsync?: (record: OperationExecutionRecord) => void;
+    beforeExecuteOperationsAsync?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
+}
+/**
+ * A class which manages the execution of a set of tasks with interdependencies.
+ * Initially, and at the end of each task execution, all unblocked tasks
+ * are added to a ready queue which is then executed. This is done continually until all
+ * tasks are complete, or prematurely fails if any of the tasks fail.
+ */
+export declare class OperationExecutionManager {
+    private readonly _executionRecords;
+    private readonly _quietMode;
+    private readonly _parallelism;
+    private readonly _allowOversubscription;
+    private readonly _totalOperations;
+    private readonly _outputWritable;
+    private readonly _colorsNewlinesTransform;
+    private readonly _streamCollator;
+    private readonly _terminal;
+    private readonly _beforeExecuteOperation?;
+    private readonly _afterExecuteOperation?;
+    private readonly _onOperationStatusChanged?;
+    private readonly _beforeExecuteOperations?;
+    private readonly _createEnvironmentForOperation?;
+    private _hasAnyFailures;
+    private _hasAnyNonAllowedWarnings;
+    private _hasAnyAborted;
+    private _completedOperations;
+    private _executionQueue;
+    constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
+    private _streamCollator_onWriterActive;
+    /**
+     * Executes all operations which have been registered, returning a promise which is resolved when all the
+     * operations are completed successfully, or rejects when any operation fails.
+     */
+    executeAsync(abortController: AbortController): Promise<IExecutionResult>;
+    private _reportOperationErrorIfAny;
+    /**
+     * Handles the result of the operation and propagates any relevant effects.
+     */
+    private _onOperationComplete;
+}
+//# sourceMappingURL=OperationExecutionManager.d.ts.map

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

@@ -7,7 +7,7 @@ import { Stopwatch } from '../../utilities/Stopwatch';
 import { OperationMetadataManager } from './OperationMetadataManager';
 import type { IPhase } from '../../api/CommandLineConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
-import type { IOperationExecutionResult, IOperationStateHashComponents } from './IOperationExecutionResult';
+import type { IOperationExecutionResult } from './IOperationExecutionResult';
 import type { IInputsSnapshot } from '../incremental/InputsSnapshot';
 import type { IEnvironment } from '../../utilities/Utilities';
 import { type ILogFilePaths } from './ProjectLogWritable';
@@ -16,22 +16,12 @@ import { type ILogFilePaths } from './ProjectLogWritable';
  */
 export interface IOperationExecutionRecordContext {
     streamCollator: StreamCollator;
-    onOperationStateChanged?: (record: OperationExecutionRecord) => void;
+    onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     createEnvironment?: (record: OperationExecutionRecord) => IEnvironment;
-    invalidate?: (operations: Iterable<Operation>, reason: string) => void;
     inputsSnapshot: IInputsSnapshot | undefined;
-    maxParallelism: number;
     debugMode: boolean;
     quietMode: boolean;
 }
-/**
- * Context object for the executeAsync() method.
- * @internal
- */
-export interface IOperationExecutionContext {
-    onStartAsync: (record: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
-    onResultAsync: (record: OperationExecutionRecord) => Promise<void>;
-}
 /**
  * Internal class representing everything about executing an operation
  *
@@ -47,10 +37,6 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * it later (for example to re-print errors at end of execution).
      */
     error: Error | undefined;
-    /**
-     * If true, this operation should be executed. If false, it should be skipped.
-     */
-    enabled: boolean;
     /**
      * This number represents how far away this Operation is from the furthest "root" operation (i.e.
      * an operation with no consumers). This helps us to calculate the critical path (i.e. the
@@ -95,7 +81,6 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     readonly stdioSummarizer: StdioSummarizer;
     readonly problemCollector: ProblemCollector;
     readonly runner: IOperationRunner;
-    readonly weight: number;
     readonly associatedPhase: IPhase;
     readonly associatedProject: RushConfigurationProject;
     readonly _operationMetadataManager: OperationMetadataManager;
@@ -107,14 +92,14 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     private _stateHashComponents;
     constructor(operation: Operation, context: IOperationExecutionRecordContext);
     get name(): string;
+    get weight(): number;
     get debugMode(): boolean;
     get quietMode(): boolean;
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
     get cobuildRunnerId(): string | undefined;
     get environment(): IEnvironment | undefined;
-    getInvalidateCallback(): (reason: string) => void;
-    get metadataFolderPath(): string;
+    get metadataFolderPath(): string | undefined;
     get isTerminal(): boolean;
     /**
      * The current execution status of an operation. Operations start in the 'ready' state,
@@ -126,7 +111,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     set status(newStatus: OperationStatus);
     get silent(): boolean;
     getStateHash(): string;
-    getStateHashComponents(): IOperationStateHashComponents;
+    getStateHashComponents(): ReadonlyArray<string>;
     /**
      * {@inheritdoc IOperationRunnerContext.runWithTerminalAsync}
      */
@@ -134,6 +119,9 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
         createLogFile: boolean;
         logFileSuffix: string;
     }): Promise<T>;
-    executeAsync(lastState: OperationExecutionRecord | undefined, executeContext: IOperationExecutionContext): Promise<void>;
+    executeAsync({ onStart, onResult }: {
+        onStart: (record: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
+        onResult: (record: OperationExecutionRecord) => Promise<void>;
+    }): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

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

@@ -57,8 +57,4 @@ export declare enum OperationStatus {
  * @alpha
  */
 export declare const TERMINAL_STATUSES: Set<OperationStatus>;
-/**
- * The set of statuses that are considered successful and don't trigger a rebuild if current.
- */
-export declare const SUCCESS_STATUSES: Set<OperationStatus>;
 //# sourceMappingURL=OperationStatus.d.ts.map

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

@@ -1,13 +1,12 @@
 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 IShellOperationRunnerOptions {
     phase: IPhase;
     rushProject: RushConfigurationProject;
     displayName: string;
-    initialCommand: string;
-    incrementalCommand: string | undefined;
+    commandToRun: string;
     commandForHash: string;
     ignoredParameterValues: ReadonlyArray<string>;
 }
@@ -22,18 +21,18 @@ export declare class ShellOperationRunner implements IOperationRunner {
     readonly silent: boolean;
     readonly cacheable: boolean;
     readonly warningsAreAllowed: boolean;
+    readonly commandToRun: string;
     /**
      * The creator is expected to use a different runner if the command is known to be a noop.
      */
     readonly isNoOp: boolean;
     private readonly _commandForHash;
-    private readonly _initialCommand;
-    private readonly _incrementalCommand;
     private readonly _rushProject;
     private readonly _ignoredParameterValues;
     constructor(options: IShellOperationRunnerOptions);
-    executeAsync(context: IOperationRunnerContext, lastState?: IOperationLastState): Promise<OperationStatus>;
+    executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     getConfigHash(): string;
+    private _executeAsync;
 }
 /**
  * When running a command from the "scripts" block in package.json, if the command

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

@@ -16,8 +16,7 @@ export declare function initializeShellOperationRunner(options: {
     project: RushConfigurationProject;
     displayName: string;
     rushConfiguration: RushConfiguration;
-    initialCommand: string | undefined;
-    incrementalCommand: string | undefined;
+    commandToRun: string | undefined;
     commandForHash?: string;
     customParameterValues: ReadonlyArray<string>;
     ignoredParameterValues: ReadonlyArray<string>;

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

@@ -1,11 +1,13 @@
 import type { ITerminal } from '@rushstack/terminal';
 import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
 /**
- * Core phased command plugin that verifies correctness of the entries in rush-project.json
+ * Core phased command plugin that provides the functionality for generating a base operation graph
+ * from the set of selected projects and phases.
  */
 export declare class ValidateOperationsPlugin implements IPhasedCommandPlugin {
     private readonly _terminal;
     constructor(terminal: ITerminal);
     apply(hooks: PhasedCommandHooks): void;
+    private _validateOperations;
 }
 //# sourceMappingURL=ValidateOperationsPlugin.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+/**
+ * Add weights to operations based on the operation settings in rush-project.json.
+ *
+ * This also sets the weight of no-op operations to 0.
+ */
+export declare class WeightedOperationPlugin implements IPhasedCommandPlugin {
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=WeightedOperationPlugin.d.ts.map

package/lib-dts/pluginFramework/PhasedCommandHooks.d.ts

@@ -1,15 +1,18 @@
-import { AsyncSeriesHook, AsyncSeriesWaterfallHook } from 'tapable';
+import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook, SyncWaterfallHook } from 'tapable';
 import type { CommandLineParameter } from '@rushstack/ts-command-line';
 import type { BuildCacheConfiguration } from '../api/BuildCacheConfiguration';
 import type { IPhase } from '../api/CommandLineConfiguration';
 import type { RushConfiguration } from '../api/RushConfiguration';
 import type { RushConfigurationProject } from '../api/RushConfigurationProject';
 import type { Operation } from '../logic/operations/Operation';
+import type { IExecutionResult, IOperationExecutionResult } from '../logic/operations/IOperationExecutionResult';
 import type { CobuildConfiguration } from '../api/CobuildConfiguration';
 import type { RushProjectConfiguration } from '../api/RushProjectConfiguration';
-import type { Parallelism } from '../logic/operations/ParseParallelism';
+import type { IOperationRunnerContext } from '../logic/operations/IOperationRunner';
+import type { ITelemetryData } from '../logic/Telemetry';
+import type { OperationStatus } from '../logic/operations/OperationStatus';
 import type { IInputsSnapshot } from '../logic/incremental/InputsSnapshot';
-import type { IOperationGraph } from '../logic/operations/IOperationGraph';
+import type { IEnvironment } from '../utilities/Utilities';
 /**
  * A plugin that interacts with a phased commands.
  * @alpha
@@ -44,15 +47,16 @@ export interface ICreateOperationsContext {
      * Maps from the `longName` field in command-line.json to the parser configuration in ts-command-line.
      */
     readonly customParameters: ReadonlyMap<string, CommandLineParameter>;
-    /**
-     * If true, dependencies of the selected phases will be automatically enabled in the execution.
-     */
-    readonly includePhaseDeps: boolean;
     /**
      * If true, projects may read their output from cache or be skipped if already up to date.
      * If false, neither of the above may occur, e.g. "rush rebuild"
      */
     readonly isIncrementalBuildAllowed: boolean;
+    /**
+     * If true, this is the initial run of the command.
+     * If false, this execution is in response to changes.
+     */
+    readonly isInitial: boolean;
     /**
      * If true, the command is running in watch mode.
      */
@@ -60,62 +64,124 @@ export interface ICreateOperationsContext {
     /**
      * The currently configured maximum parallelism for the command.
      */
-    readonly parallelism: Parallelism;
+    readonly parallelism: number;
     /**
-     * The set of phases selected for execution.
+     * The set of phases original for the current command execution.
      */
-    readonly phaseSelection: ReadonlySet<IPhase>;
+    readonly phaseOriginal: ReadonlySet<IPhase>;
     /**
-     * All successfully loaded rush-project.json data for selected projects.
+     * The set of phases selected for the current command execution.
      */
-    readonly projectConfigurations: ReadonlyMap<RushConfigurationProject, RushProjectConfiguration>;
+    readonly phaseSelection: ReadonlySet<IPhase>;
     /**
-     * The set of Rush projects selected for execution.
+     * The set of Rush projects selected for the current command execution.
      */
     readonly projectSelection: ReadonlySet<RushConfigurationProject>;
     /**
-     * If true, the operation graph should include all projects in the repository (watch broad graph mode).
-     * Only the projects in projectSelection should start enabled; others are present but disabled.
+     * 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`.
      */
-    readonly generateFullGraph?: boolean;
+    readonly projectsInUnknownState: ReadonlySet<RushConfigurationProject>;
     /**
      * The Rush configuration
      */
     readonly rushConfiguration: RushConfiguration;
+    /**
+     * If true, Rush will automatically include the dependent phases for the specified set of phases.
+     * @remarks
+     * If the selection of projects was "unsafe" (i.e. missing some dependencies), this will add the
+     * minimum number of phases required to make it safe.
+     */
+    readonly includePhaseDeps: boolean;
+    /**
+     * Marks an operation's result as invalid, potentially triggering a new build. Only applicable in watch mode.
+     * @param operation - The operation to invalidate
+     * @param reason - The reason for invalidating the operation
+     */
+    readonly invalidateOperation?: ((operation: Operation, reason: string) => void) | undefined;
 }
 /**
- * Context used for configuring the operation graph.
+ * Context used for executing operations.
  * @alpha
  */
-export interface IOperationGraphContext extends ICreateOperationsContext {
+export interface IExecuteOperationsContext extends ICreateOperationsContext {
     /**
      * The current state of the repository, if available.
      * Not part of the creation context to avoid the overhead of Git calls when initializing the graph.
      */
-    readonly initialSnapshot?: IInputsSnapshot;
+    readonly inputsSnapshot?: IInputsSnapshot;
+    /**
+     * An abort controller that can be used to abort the current set of queued operations.
+     */
+    readonly abortController: AbortController;
 }
 /**
- * Hooks into the execution process for phased commands.
- *
- * Lifecycle:
- * 1. `createOperationsAsync` - Invoked to populate the set of operations for execution.
- * 2. `onGraphCreatedAsync` - Invoked after the operation graph is created, allowing plugins to
- *    tap into graph-level hooks (e.g. `configureIteration`, `onIdle`).
- *    See {@link OperationGraphHooks} for the per-iteration lifecycle.
- *
+ * Hooks into the execution process for phased commands
  * @alpha
  */
 export declare class PhasedCommandHooks {
     /**
      * Hook invoked to create operations for execution.
+     * Use the context to distinguish between the initial run and phased runs.
+     */
+    readonly createOperations: AsyncSeriesWaterfallHook<[Set<Operation>, ICreateOperationsContext]>;
+    /**
+     * Hook invoked before operation start
+     * Hook is series for stable output.
      */
-    readonly createOperationsAsync: AsyncSeriesWaterfallHook<[
-        Set<Operation>,
-        ICreateOperationsContext
+    readonly beforeExecuteOperations: AsyncSeriesHook<[
+        Map<Operation, IOperationExecutionResult>,
+        IExecuteOperationsContext
     ]>;
     /**
-     * Hook invoked when the operation graph is created, allowing the plugin to tap into it and interact with it.
+     * Hook invoked when operation status changed
+     * Hook is series for stable output.
+     */
+    readonly onOperationStatusChanged: SyncHook<[IOperationExecutionResult]>;
+    /**
+     * Hook invoked after executing a set of operations.
+     * Use the context to distinguish between the initial run and phased runs.
+     * Hook is series for stable output.
+     */
+    readonly afterExecuteOperations: AsyncSeriesHook<[IExecutionResult, IExecuteOperationsContext]>;
+    /**
+     * Hook invoked before executing a operation.
+     */
+    readonly beforeExecuteOperation: AsyncSeriesBailHook<[
+        IOperationRunnerContext & IOperationExecutionResult
+    ], OperationStatus | undefined>;
+    /**
+     * Hook invoked to define environment variables for an operation.
+     * May be invoked by the runner to get the environment for the operation.
+     */
+    readonly createEnvironmentForOperation: SyncWaterfallHook<[
+        IEnvironment,
+        IOperationRunnerContext & IOperationExecutionResult
+    ]>;
+    /**
+     * Hook invoked after executing a operation.
+     */
+    readonly afterExecuteOperation: AsyncSeriesHook<[
+        IOperationRunnerContext & IOperationExecutionResult
+    ]>;
+    /**
+     * Hook invoked to shutdown long-lived work in plugins.
+     */
+    readonly shutdownAsync: AsyncParallelHook<void>;
+    /**
+     * 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.
+     * Only relevant when running in watch mode.
+     */
+    readonly waitingForChanges: SyncHook<void>;
+    /**
+     * Hook invoked after executing operations and before waitingForChanges. Allows the caller
+     * to augment or modify the log entry about to be written.
      */
-    readonly onGraphCreatedAsync: AsyncSeriesHook<[IOperationGraph, IOperationGraphContext]>;
+    readonly beforeLog: SyncHook<ITelemetryData, void>;
 }
 //# sourceMappingURL=PhasedCommandHooks.d.ts.map

package/lib-dts/utilities/Stopwatch.d.ts

@@ -44,13 +44,13 @@ export declare class Stopwatch implements IStopwatchResult {
     /**
      * Static helper function which creates a stopwatch which is immediately started
      */
-    static start(startTimeOverride?: number): Stopwatch;
+    static start(): Stopwatch;
     get state(): StopwatchState;
     /**
      * Starts the stopwatch. Note that if end() has been called,
      * reset() should be called before calling start() again.
      */
-    start(startTimeOverride?: number): Stopwatch;
+    start(): Stopwatch;
     /**
      * Stops executing the stopwatch and saves the current timestamp
      */

package/lib-shim/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rushstack/rush-sdk",
-  "version": "5.170.1-pr5378.0",
+  "version": "5.171.0",
   "description": "An API for interacting with the Rush engine",
   "repository": {
     "type": "git",
@@ -40,23 +40,23 @@
     "@pnpm/lockfile.types-900": "npm:@pnpm/lockfile.types@~900.0.0",
     "tapable": "2.2.1",
     "@rushstack/credential-cache": "0.2.7",
-    "@rushstack/node-core-library": "5.20.3",
     "@rushstack/lookup-by-path": "0.9.7",
+    "@rushstack/terminal": "0.22.3",
     "@rushstack/package-deps-hash": "4.7.7",
-    "@rushstack/terminal": "0.22.3"
+    "@rushstack/node-core-library": "5.20.3"
   },
   "devDependencies": {
     "@types/semver": "7.5.0",
     "@types/webpack-env": "1.18.8",
     "eslint": "~9.37.0",
     "webpack": "~5.105.2",
-    "@microsoft/rush-lib": "5.170.1-pr5378.0",
+    "@microsoft/rush-lib": "5.171.0",
     "@rushstack/heft": "1.2.7",
-    "@rushstack/stream-collator": "4.2.7",
-    "@rushstack/ts-command-line": "5.3.3",
     "@rushstack/heft-webpack5-plugin": "1.3.7",
-    "local-node-rig": "1.0.0",
-    "@rushstack/webpack-preserve-dynamic-require-plugin": "0.12.8"
+    "@rushstack/ts-command-line": "5.3.3",
+    "@rushstack/stream-collator": "4.2.7",
+    "@rushstack/webpack-preserve-dynamic-require-plugin": "0.12.8",
+    "local-node-rig": "1.0.0"
   },
   "sideEffects": false,
   "scripts": {

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

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

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

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

package/lib-commonjs/pluginFramework/OperationGraphHooks.js

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

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

@@ -1,137 +0,0 @@
-import type { TerminalWritable } from '@rushstack/terminal';
-import type { Operation } from './Operation';
-import type { IOperationExecutionResult } from './IOperationExecutionResult';
-import type { Parallelism } from './ParseParallelism';
-import type { OperationStatus } from './OperationStatus';
-import type { IInputsSnapshot } from '../incremental/InputsSnapshot';
-import type { OperationGraphHooks } from '../../pluginFramework/OperationGraphHooks';
-/**
- * Options for a single iteration of operation execution.
- * @alpha
- */
-export interface IOperationGraphIterationOptions {
-    inputsSnapshot?: IInputsSnapshot;
-    /**
-     * The time when the iteration was scheduled, if available, as returned by `performance.now()`.
-     */
-    startTime?: number;
-}
-/**
- * Public API for the operation graph.
- * @alpha
- */
-export interface IOperationGraph {
-    /**
-     * Hooks into the execution process for operations
-     */
-    readonly hooks: OperationGraphHooks;
-    /**
-     * The set of operations in the graph.
-     */
-    readonly operations: ReadonlySet<Operation>;
-    /**
-     * A map from each `Operation` in the graph to its current result record.
-     * The map is updated in real time as operations execute during an iteration.
-     * Only statuses representing a completed execution (e.g. `Success`, `Failure`,
-     * `SuccessWithWarning`) write to this map; statuses such as `Skipped` or `Aborted` —
-     * which indicate that an operation did not actually run — do not update it.
-     * For operations that have not yet run in the current iteration, the map retains the
-     * result from whichever prior iteration the operation last ran in.
-     * An entry with status `Ready` indicates that the operation is considered stale and
-     * has been queued to run again.
-     * Empty until at least one operation has completed execution.
-     */
-    readonly resultByOperation: ReadonlyMap<Operation, IOperationExecutionResult>;
-    /**
-     * The maximum allowed parallelism for this operation graph.
-     * Reads as a concrete integer. Accepts a `Parallelism` value and coerces it on write.
-     */
-    get parallelism(): number;
-    set parallelism(value: Parallelism);
-    /**
-     * If additional debug information should be printed during execution.
-     */
-    debugMode: boolean;
-    /**
-     * If true, operations will be executed in "quiet mode" where only errors are reported.
-     */
-    quietMode: boolean;
-    /**
-     * If true, allow operations to oversubscribe the CPU. Defaults to true.
-     */
-    allowOversubscription: boolean;
-    /**
-     * When true, the operation graph will pause before running the next iteration (manual mode).
-     * When false, iterations run automatically when scheduled.
-     */
-    pauseNextIteration: boolean;
-    /**
-     * The current overall status of the execution.
-     */
-    readonly status: OperationStatus;
-    /**
-     * The current set of terminal destinations.
-     */
-    readonly terminalDestinations: ReadonlySet<TerminalWritable>;
-    /**
-     * True if there is a scheduled (but not yet executing) iteration.
-     * This will be false while an iteration is actively executing, or when no work is scheduled.
-     */
-    readonly hasScheduledIteration: boolean;
-    /**
-     * AbortController controlling the lifetime of the overall session (e.g. watch mode).
-     * Aborting this controller should signal all listeners (such as file system watchers) to dispose
-     * and prevent further iterations from being scheduled.
-     */
-    readonly abortController: AbortController;
-    /**
-     * Abort the current execution iteration, if any. Operations that have already started
-     * will run to completion; only operations that have not yet begun will be aborted.
-     */
-    abortCurrentIterationAsync(): Promise<void>;
-    /**
-     * Cleans up any resources used by the operation runners, if applicable.
-     * @param operations - The operations whose runners should be closed, or undefined to close all runners.
-     */
-    closeRunnersAsync(operations?: Iterable<Operation>): Promise<void>;
-    /**
-     * Executes a single iteration of the operations.
-     * @param options - Options for this execution iteration.
-     * @returns A promise that resolves to true if the iteration has work to be done, or false if the iteration was empty and therefore not scheduled.
-     */
-    scheduleIterationAsync(options: IOperationGraphIterationOptions): Promise<boolean>;
-    /**
-     * Executes all operations in the currently scheduled iteration, if any.
-     * @returns A promise which is resolved when all operations have been processed to a final state.
-     */
-    executeScheduledIterationAsync(): Promise<boolean>;
-    /**
-     * Invalidates the specified operations, causing them to be re-executed.
-     * @param operations - The operations to invalidate, or undefined to invalidate all operations.
-     * @param reason - Optional reason for invalidation.
-     */
-    invalidateOperations(operations?: Iterable<Operation>, reason?: string): void;
-    /**
-     * Sets the enabled state for a collection of operations.
-     *
-     * @param operations - The operations whose enabled state should be updated.
-     * @param targetState - The target enabled state to apply.
-     * @param mode - 'unsafe' to directly mutate only the provided operations, 'safe' to also enable
-     * transitive dependencies of enabled operations and disable transitive dependents of disabled operations.
-     * @returns true if any operation's enabled state changed, false otherwise.
-     */
-    setEnabledStates(operations: Iterable<Operation>, targetState: Operation['enabled'], mode: 'safe' | 'unsafe'): boolean;
-    /**
-     * Adds a terminal destination for output. Only new output will be sent to the destination.
-     * @param destination - The destination to add.
-     */
-    addTerminalDestination(destination: TerminalWritable): void;
-    /**
-     * Removes a terminal destination for output. Optionally closes the stream.
-     * New output will no longer be sent to the destination.
-     * @param destination - The destination to remove.
-     * @param close - Whether to close the stream. Defaults to `true`.
-     */
-    removeTerminalDestination(destination: TerminalWritable, close?: boolean): boolean;
-}
-//# sourceMappingURL=IOperationGraph.d.ts.map