@rushstack/rush-sdk 5.147.2 → 5.149.0

package/dist/rush-lib.d.ts

@@ -24,6 +24,7 @@ import { LookupByPath } from '@rushstack/lookup-by-path';
 import { PackageNameParser } from '@rushstack/node-core-library';
 import type { StdioSummarizer } from '@rushstack/terminal';
 import { SyncHook } from 'tapable';
+import { SyncWaterfallHook } from 'tapable';
 import { Terminal } from '@rushstack/terminal';
 
 /**
@@ -1476,6 +1477,14 @@ export declare interface IExperimentsJson {
      * When this toggle is enabled, Rush will only scan specific paths, significantly speeding up Git operations.
      */
     enableSubpathScan?: boolean;
+    /**
+     * Rush has a policy that normally requires Rush projects to specify `workspace:*` in package.json when depending
+     * on other projects in the workspace, unless they are explicitly declared as `decoupledLocalDependencies`
+     * in rush.json.  Enabling this experiment will remove that requirement for dependencies belonging to a different
+     * subspace.  This is useful for large product groups who work in separate subspaces and generally prefer to consume
+     * each other's packages via the NPM registry.
+     */
+    exemptDecoupledDependenciesBetweenSubspaces?: boolean;
 }
 
 /**
@@ -1902,6 +1911,11 @@ export declare interface IOperationRunnerContext {
      * 'failure'.
      */
     status: OperationStatus;
+    /**
+     * The environment in which the operation is being executed.
+     * A return value of `undefined` indicates that it should inherit the environment from the parent process.
+     */
+    environment: IEnvironment | undefined;
     /**
      * 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).
@@ -3088,6 +3102,14 @@ export declare class PhasedCommandHooks {
     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.
      */

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.48.1"
+      "packageVersion": "7.50.0"
     }
   ]
 }

package/lib/api/ExperimentsConfiguration.d.ts

@@ -94,6 +94,14 @@ export interface IExperimentsJson {
      * When this toggle is enabled, Rush will only scan specific paths, significantly speeding up Git operations.
      */
     enableSubpathScan?: boolean;
+    /**
+     * Rush has a policy that normally requires Rush projects to specify `workspace:*` in package.json when depending
+     * on other projects in the workspace, unless they are explicitly declared as `decoupledLocalDependencies`
+     * in rush.json.  Enabling this experiment will remove that requirement for dependencies belonging to a different
+     * subspace.  This is useful for large product groups who work in separate subspaces and generally prefer to consume
+     * each other's packages via the NPM registry.
+     */
+    exemptDecoupledDependenciesBetweenSubspaces?: boolean;
 }
 /**
  * Use this class to load the "common/config/rush/experiments.json" config file.

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

@@ -53,6 +53,7 @@ export declare class PhasedScriptAction extends BaseScriptAction<IPhasedCommandC
     private readonly _installParameter;
     private readonly _variantParameter;
     private readonly _noIPCParameter;
+    private readonly _nodeDiagnosticDirParameter;
     constructor(options: IPhasedScriptActionOptions);
     runAsync(): Promise<void>;
     private _runInitialPhasesAsync;

package/lib/logic/buildCache/ProjectBuildCache.d.ts

@@ -1,32 +1,35 @@
 import type { ITerminal } from '@rushstack/terminal';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
-export interface IProjectBuildCacheOptions {
+import type { OperationExecutionRecord } from '../operations/OperationExecutionRecord';
+export interface IOperationBuildCacheOptions {
     /**
      * The repo-wide configuration for the build cache.
      */
     buildCacheConfiguration: BuildCacheConfiguration;
     /**
-     * The project to be cached.
+     * The terminal to use for logging.
      */
-    project: RushConfigurationProject;
+    terminal: ITerminal;
+}
+export type IProjectBuildCacheOptions = IOperationBuildCacheOptions & {
     /**
      * Value from rush-project.json
      */
     projectOutputFolderNames: ReadonlyArray<string>;
     /**
-     * The hash of all relevant inputs and configuration that uniquely identifies this execution.
+     * The project to be cached.
      */
-    operationStateHash: string;
+    project: RushConfigurationProject;
     /**
-     * The terminal to use for logging.
+     * The hash of all relevant inputs and configuration that uniquely identifies this execution.
      */
-    terminal: ITerminal;
+    operationStateHash: string;
     /**
      * The name of the phase that is being cached.
      */
     phaseName: string;
-}
+};
 export declare class ProjectBuildCache {
     private static _tarUtilityPromise;
     private readonly _project;
@@ -40,6 +43,7 @@ export declare class ProjectBuildCache {
     private static _tryGetTarUtility;
     get cacheId(): string | undefined;
     static getProjectBuildCache(options: IProjectBuildCacheOptions): ProjectBuildCache;
+    static forOperation(operation: OperationExecutionRecord, options: IOperationBuildCacheOptions): ProjectBuildCache;
     tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     /**

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

@@ -3,6 +3,7 @@ import type { CollatedWriter } from '@rushstack/stream-collator';
 import type { OperationStatus } from './OperationStatus';
 import type { OperationMetadataManager } from './OperationMetadataManager';
 import type { IStopwatchResult } from '../../utilities/Stopwatch';
+import type { IEnvironment } from '../../utilities/Utilities';
 /**
  * Information passed to the executing `IOperationRunner`
  *
@@ -38,6 +39,11 @@ export interface IOperationRunnerContext {
      * 'failure'.
      */
     status: OperationStatus;
+    /**
+     * The environment in which the operation is being executed.
+     * A return value of `undefined` indicates that it should inherit the environment from the parent process.
+     */
+    environment: IEnvironment | undefined;
     /**
      * 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).

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

@@ -6,7 +6,8 @@ export interface IIPCOperationRunnerOptions {
     phase: IPhase;
     project: RushConfigurationProject;
     name: string;
-    shellCommand: string;
+    commandToRun: string;
+    commandForHash: string;
     persist: boolean;
     requestRun: (requestor?: string) => void;
 }
@@ -19,9 +20,9 @@ export declare class IPCOperationRunner implements IOperationRunner {
     readonly reportTiming: boolean;
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
-    private readonly _rushConfiguration;
-    private readonly _shellCommand;
-    private readonly _workingDirectory;
+    private readonly _rushProject;
+    private readonly _commandToRun;
+    private readonly _commandForHash;
     private readonly _persist;
     private readonly _requestRun;
     private _ipcProcess;

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

@@ -0,0 +1,13 @@
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface INodeDiagnosticDirPluginOptions {
+    diagnosticDir: string;
+}
+/**
+ * Phased command plugin that configures the NodeJS --diagnostic-dir option to contain the project and phase name.
+ */
+export declare class NodeDiagnosticDirPlugin implements IPhasedCommandPlugin {
+    private readonly _diagnosticsDir;
+    constructor(options: INodeDiagnosticDirPluginOptions);
+    apply(hooks: PhasedCommandHooks): void;
+}
+//# sourceMappingURL=NodeDiagnosticDirPlugin.d.ts.map

package/lib/logic/operations/NodeDiagnosticDirPlugin.js

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

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

@@ -3,6 +3,7 @@ import type { Operation } from './Operation';
 import { OperationStatus } from './OperationStatus';
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 import type { IExecutionResult } from './IOperationExecutionResult';
+import type { IEnvironment } from '../../utilities/Utilities';
 export interface IOperationExecutionManagerOptions {
     quietMode: boolean;
     debugMode: boolean;
@@ -11,6 +12,7 @@ export interface IOperationExecutionManagerOptions {
     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>;
 }
@@ -34,6 +36,7 @@ export declare class OperationExecutionManager {
     private readonly _afterExecuteOperation?;
     private readonly _onOperationStatusChanged?;
     private readonly _beforeExecuteOperations?;
+    private readonly _createEnvironmentForOperation?;
     private _hasAnyFailures;
     private _hasAnyNonAllowedWarnings;
     private _completedOperations;

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

@@ -9,9 +9,13 @@ import type { IPhase } from '../../api/CommandLineConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import { type ILogFilePaths } from './ProjectLogWritable';
 import type { IOperationExecutionResult } from './IOperationExecutionResult';
+import type { IInputsSnapshot } from '../incremental/InputsSnapshot';
+import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
+import type { IEnvironment } from '../../utilities/Utilities';
 export interface IOperationExecutionRecordContext {
     streamCollator: StreamCollator;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
+    createEnvironment?: (record: OperationExecutionRecord) => IEnvironment;
     debugMode: boolean;
     quietMode: boolean;
 }
@@ -80,6 +84,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     private readonly _context;
     private _collatedWriter;
     private _status;
+    private _stateHash;
     constructor(operation: Operation, context: IOperationExecutionRecordContext);
     get name(): string;
     get weight(): number;
@@ -88,6 +93,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
     get cobuildRunnerId(): string | undefined;
+    get environment(): IEnvironment | undefined;
     get metadataFolderPath(): string | undefined;
     get isTerminal(): boolean;
     /**
@@ -99,6 +105,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get status(): OperationStatus;
     set status(newStatus: OperationStatus);
     get silent(): boolean;
+    get stateHash(): string;
     /**
      * {@inheritdoc IOperationRunnerContext.runWithTerminalAsync}
      */
@@ -110,5 +117,9 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
         onStart: (record: OperationExecutionRecord) => Promise<OperationStatus | undefined>;
         onResult: (record: OperationExecutionRecord) => Promise<void>;
     }): Promise<void>;
+    calculateStateHash(options: {
+        inputsSnapshot: IInputsSnapshot;
+        buildCacheConfiguration: BuildCacheConfiguration;
+    }): string;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

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

@@ -1,17 +1,13 @@
 import type { IPhase } from '../../api/CommandLineConfiguration';
-import type { RushConfiguration } from '../../api/RushConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
-import { type IEnvironment } from '../../utilities/Utilities';
 import type { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
 import { OperationStatus } from './OperationStatus';
-export interface IOperationRunnerOptions {
+export interface IShellOperationRunnerOptions {
+    phase: IPhase;
     rushProject: RushConfigurationProject;
-    rushConfiguration: RushConfiguration;
+    displayName: string;
     commandToRun: string;
     commandForHash: string;
-    displayName: string;
-    phase: IPhase;
-    environment?: IEnvironment;
 }
 /**
  * An `IOperationRunner` subclass that performs an operation via a shell command.
@@ -24,12 +20,10 @@ export declare class ShellOperationRunner implements IOperationRunner {
     readonly silent: boolean;
     readonly cacheable: boolean;
     readonly warningsAreAllowed: boolean;
-    private readonly _commandToRun;
+    readonly commandToRun: string;
     private readonly _commandForHash;
     private readonly _rushProject;
-    private readonly _rushConfiguration;
-    private readonly _environment?;
-    constructor(options: IOperationRunnerOptions);
+    constructor(options: IShellOperationRunnerOptions);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     getConfigHash(): string;
     private _executeAsync;

package/lib/pluginFramework/PhasedCommandHooks.d.ts

@@ -1,4 +1,4 @@
-import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } 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';
@@ -12,6 +12,7 @@ import type { IOperationRunnerContext } from '../logic/operations/IOperationRunn
 import type { ITelemetryData } from '../logic/Telemetry';
 import type { OperationStatus } from '../logic/operations/OperationStatus';
 import type { IInputsSnapshot } from '../logic/incremental/InputsSnapshot';
+import type { IEnvironment } from '../utilities/Utilities';
 /**
  * A plugin that interacts with a phased commands.
  * @alpha
@@ -132,6 +133,14 @@ export declare class PhasedCommandHooks {
     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.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rushstack/rush-sdk",
-  "version": "5.147.2",
+  "version": "5.149.0",
   "description": "An API for interacting with the Rush engine",
   "repository": {
     "type": "git",
@@ -35,22 +35,22 @@
   "dependencies": {
     "@pnpm/lockfile.types": "~1.0.3",
     "tapable": "2.2.1",
-    "@rushstack/lookup-by-path": "0.5.0",
-    "@rushstack/package-deps-hash": "4.3.1",
-    "@rushstack/node-core-library": "5.10.1",
-    "@rushstack/terminal": "0.14.4"
+    "@rushstack/lookup-by-path": "0.5.5",
+    "@rushstack/package-deps-hash": "4.3.6",
+    "@rushstack/terminal": "0.15.0",
+    "@rushstack/node-core-library": "5.11.0"
   },
   "devDependencies": {
     "@types/semver": "7.5.0",
     "@types/webpack-env": "1.18.0",
     "webpack": "~5.95.0",
-    "@rushstack/heft": "0.68.11",
-    "@microsoft/rush-lib": "5.147.2",
-    "@rushstack/stream-collator": "4.1.79",
+    "@microsoft/rush-lib": "5.149.0",
+    "@rushstack/heft": "0.68.16",
     "local-node-rig": "1.0.0",
-    "@rushstack/heft-webpack5-plugin": "0.11.9",
-    "@rushstack/webpack-preserve-dynamic-require-plugin": "0.11.78",
-    "@rushstack/ts-command-line": "4.23.2"
+    "@rushstack/heft-webpack5-plugin": "0.11.14",
+    "@rushstack/ts-command-line": "4.23.5",
+    "@rushstack/stream-collator": "4.1.84",
+    "@rushstack/webpack-preserve-dynamic-require-plugin": "0.11.83"
   },
   "scripts": {
     "build": "heft build --clean",