@rushstack/rush-sdk 5.97.0 → 5.97.1-pr3481.18

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

@@ -1,10 +1,10 @@
 import { ITerminal } from '@rushstack/node-core-library';
+import { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
-import { RushProjectConfiguration } from '../../api/RushProjectConfiguration';
 import { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 export interface IProjectBuildCacheOptions {
     buildCacheConfiguration: BuildCacheConfiguration;
-    projectConfiguration: RushProjectConfiguration;
+    project: RushConfigurationProject;
     projectOutputFolderNames: ReadonlyArray<string>;
     additionalProjectOutputFilePaths?: ReadonlyArray<string>;
     additionalContext?: Record<string, string>;
@@ -30,10 +30,11 @@ export declare class ProjectBuildCache {
     private _cacheId;
     private constructor();
     private static _tryGetTarUtility;
+    get cacheId(): string | undefined;
     static tryGetProjectBuildCache(options: IProjectBuildCacheOptions): Promise<ProjectBuildCache | undefined>;
     private static _validateProject;
-    tryRestoreFromCacheAsync(terminal: ITerminal): Promise<boolean>;
-    trySetCacheEntryAsync(terminal: ITerminal): Promise<boolean>;
+    tryRestoreFromCacheAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
+    trySetCacheEntryAsync(terminal: ITerminal, specifiedCacheId?: string): Promise<boolean>;
     /**
      * Walks the declared output folders of the project and collects a list of files.
      * @returns The list of output files as project-relative paths, or `undefined` if a

package/lib/logic/cobuild/CobuildLock.d.ts

@@ -0,0 +1,24 @@
+import type { CobuildConfiguration } from '../../api/CobuildConfiguration';
+import type { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import type { OperationStatus } from '../operations/OperationStatus';
+import type { ICobuildContext } from './ICobuildLockProvider';
+export interface ICobuildLockOptions {
+    cobuildConfiguration: CobuildConfiguration;
+    projectBuildCache: ProjectBuildCache;
+}
+export interface ICobuildCompletedState {
+    status: OperationStatus.Success | OperationStatus.SuccessWithWarning | OperationStatus.Failure;
+    cacheId: string;
+}
+export declare class CobuildLock {
+    readonly projectBuildCache: ProjectBuildCache;
+    readonly cobuildConfiguration: CobuildConfiguration;
+    private _cobuildContext;
+    constructor(options: ICobuildLockOptions);
+    setCompletedStateAsync(state: ICobuildCompletedState): Promise<void>;
+    getCompletedStateAsync(): Promise<ICobuildCompletedState | undefined>;
+    tryAcquireLockAsync(): Promise<boolean>;
+    renewLockAsync(): Promise<void>;
+    get cobuildContext(): ICobuildContext;
+}
+//# sourceMappingURL=CobuildLock.d.ts.map

package/lib/logic/cobuild/CobuildLock.js

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

package/lib/logic/cobuild/ICobuildLockProvider.d.ts

@@ -0,0 +1,46 @@
+import type { OperationStatus } from '../operations/OperationStatus';
+/**
+ * @beta
+ */
+export interface ICobuildContext {
+    /**
+     * 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. If user was more permissive,
+     * and wanted all PR and CI builds building anything with the same contextId to cooperate, then just
+     * set it to a static value.
+     */
+    contextId: string;
+    /**
+     * The id of cache. It should be keep same as the normal cacheId from ProjectBuildCache.
+     * Otherwise, there is a discrepancy in the success case then turning on cobuilds will
+     * fail to populate the normal build cache.
+     */
+    cacheId: string;
+    /**
+     * {@inheritdoc RushConstants.cobuildLockVersion}
+     */
+    version: number;
+}
+/**
+ * @beta
+ */
+export 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 interface ICobuildLockProvider {
+    connectAsync(): Promise<void>;
+    disconnectAsync(): Promise<void>;
+    acquireLockAsync(context: ICobuildContext): Promise<boolean>;
+    renewLockAsync(context: ICobuildContext): Promise<void>;
+    setCompletedStateAsync(context: ICobuildContext, state: ICobuildCompletedState): Promise<void>;
+    getCompletedStateAsync(context: ICobuildContext): Promise<ICobuildCompletedState | undefined>;
+}
+//# sourceMappingURL=ICobuildLockProvider.d.ts.map

package/lib/logic/cobuild/ICobuildLockProvider.js

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

package/lib/logic/installManager/InstallHelpers.d.ts

@@ -3,6 +3,7 @@ import { RushConfiguration } from '../../api/RushConfiguration';
 import { RushGlobalFolder } from '../../api/RushGlobalFolder';
 export declare class InstallHelpers {
     static generateCommonPackageJson(rushConfiguration: RushConfiguration, dependencies?: Map<string, string>): void;
+    static generateCommonSplitPackageJson(rushConfiguration: RushConfiguration): void;
     static getPackageManagerEnvironment(rushConfiguration: RushConfiguration, options?: {
         debug?: boolean;
     }): NodeJS.ProcessEnv;

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

@@ -1,6 +1,16 @@
 import { OperationExecutionRecord } from './OperationExecutionRecord';
 /**
- * Implmentation of the async iteration protocol for a collection of IOperation objects.
+ * When the queue returns an unassigned operation, it means there is at least one remote executing operation,
+ * at this time, the caller has a chance to make a decision:
+ * 1. Manually invoke `tryGetRemoteExecutingOperation()` to get the remote executing operation.
+ * 2. If there is no remote executing operation available, wait for some time and return in callback, which
+ * internally invoke `assignOperations()` to assign new operations.
+ * NOTE: the caller must wait for some time to avoid busy loop and burn CPU cycles.
+ */
+export declare const UNASSIGNED_OPERATION: 'UNASSIGNED_OPERATION';
+export declare type IOperationIteratorResult = OperationExecutionRecord | typeof UNASSIGNED_OPERATION;
+/**
+ * Implementation of the async iteration protocol for a collection of IOperation objects.
  * The async iterator will wait for an operation to be ready for execution, or terminate if there are no more operations.
  *
  * @remarks
@@ -8,9 +18,12 @@ import { OperationExecutionRecord } from './OperationExecutionRecord';
  * it must manually invoke `assignOperations()` after performing the updates, otherwise iterators will
  * stall until another operations completes.
  */
-export declare class AsyncOperationQueue implements AsyncIterable<OperationExecutionRecord>, AsyncIterator<OperationExecutionRecord> {
+export declare class AsyncOperationQueue implements AsyncIterable<IOperationIteratorResult>, AsyncIterator<IOperationIteratorResult> {
     private readonly _queue;
     private readonly _pendingIterators;
+    private readonly _totalOperations;
+    private readonly _completedOperations;
+    private _isDone;
     /**
      * @param operations - The set of operations to be executed
      * @param sortFn - A function that sorts operations in reverse priority order:
@@ -23,17 +36,23 @@ export declare class AsyncOperationQueue implements AsyncIterable<OperationExecu
      * For use with `for await (const operation of taskQueue)`
      * @see {AsyncIterator}
      */
-    next(): Promise<IteratorResult<OperationExecutionRecord>>;
+    next(): Promise<IteratorResult<IOperationIteratorResult>>;
+    /**
+     * Set a callback to be invoked when one operation is completed.
+     * If all operations are completed, set the queue to done, resolve all pending iterators in next cycle.
+     */
+    complete(record: OperationExecutionRecord): void;
     /**
      * Routes ready operations with 0 dependencies to waiting iterators. Normally invoked as part of `next()`, but
      * if the caller does not update operation dependencies prior to calling `next()`, may need to be invoked manually.
      */
     assignOperations(): void;
+    tryGetRemoteExecutingOperation(): OperationExecutionRecord | undefined;
     /**
      * Returns this queue as an async iterator, such that multiple functions iterating this object concurrently
      * receive distinct iteration results.
      */
-    [Symbol.asyncIterator](): AsyncIterator<OperationExecutionRecord>;
+    [Symbol.asyncIterator](): AsyncIterator<IOperationIteratorResult>;
 }
 export interface IOperationSortFunction {
     /**

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

@@ -0,0 +1,21 @@
+import { CobuildLock } from '../cobuild/CobuildLock';
+import { ProjectBuildCache } from '../buildCache/ProjectBuildCache';
+import type { IPhasedCommandPlugin, PhasedCommandHooks } from '../../pluginFramework/PhasedCommandHooks';
+export interface IOperationBuildCacheContext {
+    isCacheWriteAllowed: boolean;
+    isCacheReadAllowed: boolean;
+    isSkipAllowed: boolean;
+    projectBuildCache: ProjectBuildCache | undefined;
+    cobuildLock: CobuildLock | undefined;
+}
+export declare class CacheableOperationPlugin implements IPhasedCommandPlugin {
+    private _buildCacheContextByOperationRunner;
+    apply(hooks: PhasedCommandHooks): void;
+    private _applyShellOperationRunner;
+    private _getBuildCacheContextByRunner;
+    private _getBuildCacheContextByRunnerOrThrow;
+    private _tryGetProjectBuildCacheAsync;
+    private _tryGetLogOnlyProjectBuildCacheAsync;
+    private _tryGetCobuildLockAsync;
+}
+//# sourceMappingURL=CacheableOperationPlugin.d.ts.map

package/lib/logic/operations/CacheableOperationPlugin.js

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

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

@@ -2,7 +2,7 @@ import type { StdioSummarizer } from '@rushstack/terminal';
 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 { Stopwatch } from '../../utilities/Stopwatch';
 /**
  * Information passed to the executing `IOperationRunner`
  *
@@ -34,7 +34,34 @@ export interface IOperationRunnerContext {
     /**
      * Object used to track elapsed time.
      */
-    stopwatch: IStopwatchResult;
+    stopwatch: Stopwatch;
+    /**
+     * 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;
+    /**
+     * The set of operations that depend on this operation.
+     */
+    readonly consumers: Set<IOperationRunnerContext>;
+    /**
+     * The operation runner that is executing this operation.
+     */
+    readonly runner: IOperationRunner;
+    /**
+     * Normally the incremental build logic will rebuild changed projects as well as
+     * any projects that directly or indirectly depend on a changed project.
+     * If true, then the incremental build logic will only rebuild changed projects and
+     * ignore dependent projects.
+     */
+    readonly changedProjectsOnly: boolean;
 }
 /**
  * The `Operation` class is a node in the dependency graph of work that needs to be scheduled by the
@@ -48,10 +75,6 @@ export interface IOperationRunner {
      * Name of the operation, for logging.
      */
     readonly name: string;
-    /**
-     * This flag determines if the operation is allowed to be skipped if up to date.
-     */
-    isSkipAllowed: boolean;
     /**
      * Indicates that this runner's duration has meaning.
      */
@@ -65,10 +88,6 @@ export 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.
      */

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

@@ -8,6 +8,8 @@ export interface IOperationExecutionManagerOptions {
     parallelism: number;
     changedProjectsOnly: boolean;
     destination?: TerminalWritable;
+    beforeExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
+    afterExecuteOperation?: (operation: OperationExecutionRecord) => Promise<void>;
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     beforeExecuteOperations?: (records: Map<Operation, OperationExecutionRecord>) => Promise<void>;
 }
@@ -27,11 +29,14 @@ export declare class OperationExecutionManager {
     private readonly _colorsNewlinesTransform;
     private readonly _streamCollator;
     private readonly _terminal;
+    private readonly _beforeExecuteOperation?;
+    private readonly _afterExecuteOperation?;
     private readonly _onOperationStatusChanged?;
     private readonly _beforeExecuteOperations?;
     private _hasAnyFailures;
     private _hasAnyNonAllowedWarnings;
     private _completedOperations;
+    private _executionQueue;
     constructor(operations: Set<Operation>, options: IOperationExecutionManagerOptions);
     private _streamCollator_onWriterActive;
     /**

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

@@ -10,9 +10,12 @@ export interface IOperationExecutionRecordContext {
     onOperationStatusChanged?: (record: OperationExecutionRecord) => void;
     debugMode: boolean;
     quietMode: boolean;
+    changedProjectsOnly: boolean;
 }
 /**
  * Internal class representing everything about executing an operation
+ *
+ * @internal
  */
 export declare class OperationExecutionRecord implements IOperationRunnerContext {
     /**
@@ -37,6 +40,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * operation to execute, the operation with the highest criticalPathLength is chosen.
      *
      * Example:
+     * ```
      *        (0) A
      *             \
      *          (1) B     C (0)         (applications)
@@ -53,6 +57,7 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
      * X has a score of 1, since the only package which depends on it is A
      * Z has a score of 2, since only X depends on it, and X has a score of 1
      * Y has a score of 2, since the chain Y->X->C is longer than Y->C
+     * ```
      *
      * The algorithm is implemented in AsyncOperationQueue.ts as calculateCriticalPathLength()
      */
@@ -76,8 +81,9 @@ export declare class OperationExecutionRecord implements IOperationRunnerContext
     get name(): string;
     get debugMode(): boolean;
     get quietMode(): boolean;
+    get changedProjectsOnly(): boolean;
     get collatedWriter(): CollatedWriter;
     get nonCachedDurationMs(): number | undefined;
-    executeAsync(onResult: (record: OperationExecutionRecord) => void): Promise<void>;
+    executeAsync(onResult: (record: OperationExecutionRecord) => Promise<void>): Promise<void>;
 }
 //# sourceMappingURL=OperationExecutionRecord.d.ts.map

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

@@ -0,0 +1,50 @@
+import { AsyncSeriesWaterfallHook } from 'tapable';
+import type { ITerminal } from '@rushstack/node-core-library';
+import type { IOperationRunnerContext } from './IOperationRunner';
+import type { OperationStatus } from './OperationStatus';
+import type { IProjectDeps, ShellOperationRunner } from './ShellOperationRunner';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import type { IPhase } from '../../api/CommandLineConfiguration';
+/**
+ * A plugin tht interacts with a operation runner
+ */
+export interface IOperationRunnerPlugin {
+    /**
+     * Applies this plugin.
+     */
+    apply(hooks: OperationRunnerHooks): void;
+}
+export interface IOperationRunnerBeforeExecuteContext {
+    context: IOperationRunnerContext;
+    runner: ShellOperationRunner;
+    earlyReturnStatus: OperationStatus | undefined;
+    terminal: ITerminal;
+    projectDeps: IProjectDeps | undefined;
+    lastProjectDeps: IProjectDeps | undefined;
+    trackedProjectFiles: string[] | undefined;
+    logPath: string;
+    errorLogPath: string;
+    rushProject: RushConfigurationProject;
+    phase: IPhase;
+    commandName: string;
+    commandToRun: string;
+}
+export interface IOperationRunnerAfterExecuteContext {
+    context: IOperationRunnerContext;
+    terminal: ITerminal;
+    /**
+     * Exit code of the operation command
+     */
+    exitCode: number;
+    status: OperationStatus;
+    taskIsSuccessful: boolean;
+}
+/**
+ * Hooks into the lifecycle of the operation runner
+ *
+ */
+export declare class OperationRunnerHooks {
+    beforeExecute: AsyncSeriesWaterfallHook<IOperationRunnerBeforeExecuteContext>;
+    afterExecute: AsyncSeriesWaterfallHook<IOperationRunnerAfterExecuteContext>;
+}
+//# sourceMappingURL=OperationRunnerHooks.d.ts.map

package/lib/logic/operations/OperationRunnerHooks.js

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

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

@@ -7,10 +7,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
      */

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

@@ -0,0 +1,20 @@
+export declare type ICallbackFn = () => Promise<void> | void;
+export interface IPeriodicCallbackOptions {
+    interval: number;
+}
+/**
+ * A help class to run callbacks in a loop with a specified interval.
+ *
+ * @beta
+ */
+export declare class PeriodicCallback {
+    private _callbacks;
+    private _interval;
+    private _intervalId;
+    private _isRunning;
+    constructor(options: IPeriodicCallbackOptions);
+    addCallback(callback: ICallbackFn): void;
+    start(): void;
+    stop(): void;
+}
+//# sourceMappingURL=PeriodicCallback.d.ts.map

package/lib/logic/operations/PeriodicCallback.js

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

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

@@ -1,9 +1,10 @@
 import { OperationStatus } from './OperationStatus';
 import { IOperationRunner, IOperationRunnerContext } from './IOperationRunner';
+import { PeriodicCallback } from './PeriodicCallback';
+import { OperationRunnerHooks } from './OperationRunnerHooks';
 import type { RushConfiguration } from '../../api/RushConfiguration';
 import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { ProjectChangeAnalyzer } from '../ProjectChangeAnalyzer';
-import type { BuildCacheConfiguration } from '../../api/BuildCacheConfiguration';
 import type { IPhase } from '../../api/CommandLineConfiguration';
 export interface IProjectDeps {
     files: {
@@ -14,9 +15,7 @@ export interface IProjectDeps {
 export interface IOperationRunnerOptions {
     rushProject: RushConfigurationProject;
     rushConfiguration: RushConfiguration;
-    buildCacheConfiguration: BuildCacheConfiguration | undefined;
     commandToRun: string;
-    isIncrementalBuildAllowed: boolean;
     projectChangeAnalyzer: ProjectChangeAnalyzer;
     displayName: string;
     phase: IPhase;
@@ -32,31 +31,23 @@ export interface IOperationRunnerOptions {
  */
 export declare class ShellOperationRunner implements IOperationRunner {
     readonly name: string;
-    isCacheWriteAllowed: boolean;
-    isSkipAllowed: boolean;
     readonly reportTiming: boolean;
     readonly silent: boolean;
     readonly warningsAreAllowed: boolean;
+    readonly hooks: OperationRunnerHooks;
+    readonly periodicCallback: PeriodicCallback;
     private readonly _rushProject;
     private readonly _phase;
     private readonly _rushConfiguration;
-    private readonly _buildCacheConfiguration;
     private readonly _commandName;
     private readonly _commandToRun;
-    private readonly _isCacheReadAllowed;
     private readonly _projectChangeAnalyzer;
     private readonly _packageDepsFilename;
     private readonly _logFilenameIdentifier;
     private readonly _selectedPhases;
-    /**
-     * UNINITIALIZED === we haven't tried to initialize yet
-     * undefined === we didn't create one because the feature is not enabled
-     */
-    private _projectBuildCache;
     constructor(options: IOperationRunnerOptions);
     executeAsync(context: IOperationRunnerContext): Promise<OperationStatus>;
     private _executeAsync;
-    private _tryGetProjectBuildCacheAsync;
 }
 /**
  * When running a command from the "scripts" block in package.json, if the command

package/lib/logic/pnpm/IPnpmfile.d.ts

@@ -1,5 +1,6 @@
 import type { LogBase } from '@pnpm/logger';
 import type { IPackageJson } from '@rushstack/node-core-library';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 import type { IPnpmShrinkwrapYaml } from './PnpmShrinkwrapFile';
 /**
  * The `settings` parameter passed to {@link IPnpmfileShim.hooks.readPackage} and
@@ -19,6 +20,20 @@ export interface IPnpmfileShimSettings {
     workspaceVersions: Record<string, string>;
     userPnpmfilePath?: string;
 }
+export interface IWorkspaceProjectInfo extends Pick<RushConfigurationProject, 'packageName' | 'projectRelativeFolder'> {
+    packageVersion: RushConfigurationProject['packageJson']['version'];
+}
+/**
+ * The `settings` parameter passed to {@link IPnpmfileShim.hooks.readPackage} and
+ * {@link IPnpmfileShim.hooks.afterAllResolved}.
+ */
+export interface ISplitWorkspacePnpmfileShimSettings {
+    semverPath: string;
+    pathNormalizerPath: string;
+    workspaceProjects: Record<string, IWorkspaceProjectInfo>;
+    splitWorkspaceProjects: Record<string, IWorkspaceProjectInfo>;
+    userPnpmfilePath?: string;
+}
 /**
  * The `context` parameter passed to {@link IPnpmfile.hooks.readPackage}, as defined by the
  * pnpmfile API contract.
@@ -26,6 +41,7 @@ export interface IPnpmfileShimSettings {
 export interface IPnpmfileContext {
     log: (message: string) => void;
     pnpmfileShimSettings?: IPnpmfileShimSettings;
+    splitWorkspacePnpmfileShimSettings?: ISplitWorkspacePnpmfileShimSettings;
 }
 /**
  * The `log` parameter passed to {@link IPnpmfile.hooks.filterLog}.

package/lib/logic/pnpm/PnpmProjectShrinkwrapFile.d.ts

@@ -1,9 +1,15 @@
 import { BaseProjectShrinkwrapFile } from '../base/BaseProjectShrinkwrapFile';
 import { PnpmShrinkwrapFile } from './PnpmShrinkwrapFile';
+import type { RushConfigurationProject } from '../../api/RushConfigurationProject';
 /**
  *
  */
 export declare class PnpmProjectShrinkwrapFile extends BaseProjectShrinkwrapFile<PnpmShrinkwrapFile> {
+    /**
+     * When split workspace projects turn off shared-workspace-lockfiles, Pnpm creates individual
+     * shrinkwrap files for each project.
+     */
+    static generateIndividualProjectShrinkwrapAsync(project: RushConfigurationProject): Promise<void>;
     /**
      * Generate and write the project shrinkwrap file to <project>/.rush/temp/shrinkwrap-deps.json.
      * @returns True if the project shrinkwrap was created or updated, false otherwise.
@@ -16,6 +22,7 @@ export declare class PnpmProjectShrinkwrapFile extends BaseProjectShrinkwrapFile
     protected generateProjectShrinkwrapMap(): Map<string, string> | undefined;
     protected generateWorkspaceProjectShrinkwrapMap(): Map<string, string> | undefined;
     protected generateLegacyProjectShrinkwrapMap(): Map<string, string>;
+    protected generateIndividualProjectShrinkwrapMap(): Map<string, string>;
     private _addDependencyRecursive;
     private _resolveAndAddPeerDependencies;
     /**

package/lib/logic/pnpm/PnpmShrinkwrapFile.d.ts

@@ -4,6 +4,7 @@ import { RushConfiguration } from '../../api/RushConfiguration';
 import { IShrinkwrapFilePolicyValidatorOptions } from '../policy/ShrinkwrapFilePolicy';
 import { IExperimentsJson } from '../../api/ExperimentsConfiguration';
 import { RushConfigurationProject } from '../../api/RushConfigurationProject';
+import { SplitWorkspacePnpmfileConfiguration } from './SplitWorkspacePnpmfileConfiguration';
 import { PnpmProjectShrinkwrapFile } from './PnpmProjectShrinkwrapFile';
 import { PackageManagerOptionsConfigurationBase } from '../base/BasePackageManagerOptionsConfiguration';
 export interface IPeerDependenciesMetaYaml {
@@ -91,6 +92,14 @@ export interface IPnpmShrinkwrapYaml {
     dependencies: {
         [dependency: string]: string;
     };
+    /** The list of resolved version numbers for develop dependencies */
+    devDependencies: {
+        [dependency: string]: string;
+    };
+    /** The list of resolved version numbers for optional dependencies */
+    optionalDependencies: {
+        [dependency: string]: string;
+    };
     /** The list of importers for local workspace projects */
     importers: {
         [relativePath: string]: IPnpmShrinkwrapImporterYaml;
@@ -105,6 +114,10 @@ export interface IPnpmShrinkwrapYaml {
     specifiers: {
         [dependency: string]: string;
     };
+    /** The list of override version number  for dependencies */
+    overrides: {
+        [dependency: string]: string;
+    };
 }
 /**
  * Given an encoded "dependency key" from the PNPM shrinkwrap file, this parses it into an equivalent
@@ -117,15 +130,23 @@ export declare class PnpmShrinkwrapFile extends BaseShrinkwrapFile {
     readonly isWorkspaceCompatible: boolean;
     readonly registry: string;
     readonly dependencies: ReadonlyMap<string, string>;
+    readonly devDependencies: ReadonlyMap<string, string>;
+    readonly optionalDependencies: ReadonlyMap<string, string>;
     readonly importers: ReadonlyMap<string, IPnpmShrinkwrapImporterYaml>;
     readonly specifiers: ReadonlyMap<string, string>;
     readonly packages: ReadonlyMap<string, IPnpmShrinkwrapDependencyYaml>;
+    readonly overrides: ReadonlyMap<string, string>;
     private readonly _shrinkwrapJson;
     private readonly _integrities;
     private _pnpmfileConfiguration;
+    private _splitWorkspaceGlobalPnpmfileConfiguration;
+    private _individualPackageName;
+    private _individualShrinkwrapImporter;
     private constructor();
     static loadFromFile(shrinkwrapYamlFilename: string): PnpmShrinkwrapFile | undefined;
     static loadFromString(shrinkwrapContent: string): PnpmShrinkwrapFile;
+    setIndividualPackage(packageName: string, splitWorkspaceGlobalPnpmfileConfiguration?: SplitWorkspacePnpmfileConfiguration): void;
+    get isIndividual(): boolean;
     getShrinkwrapHash(experimentsConfig?: IExperimentsJson): string;
     /** @override */
     validate(packageManagerOptionsConfig: PackageManagerOptionsConfigurationBase, policyOptions: IShrinkwrapFilePolicyValidatorOptions, experimentsConfig?: IExperimentsJson): void;
@@ -192,8 +213,12 @@ export declare class PnpmShrinkwrapFile extends BaseShrinkwrapFile {
     getImporterKeyByPath(workspaceRoot: string, projectFolder: string): string;
     getImporter(importerKey: string): IPnpmShrinkwrapImporterYaml | undefined;
     getIntegrityForImporter(importerKey: string): Map<string, string> | undefined;
+    getIntegrityForIndividualProject(): Map<string, string>;
     /** @override */
     isWorkspaceProjectModifiedAsync(project: RushConfigurationProject, variant?: string): Promise<boolean>;
+    isSplitWorkspaceProjectModified(project: RushConfigurationProject): boolean;
+    isSplitWorkspaceIndividualProjectModified(project: RushConfigurationProject): boolean;
+    private _isProjectModified;
     private _getIntegrityForPackage;
     private _addIntegrities;
     /**
@@ -203,5 +228,6 @@ export declare class PnpmShrinkwrapFile extends BaseShrinkwrapFile {
     private _getPackageId;
     private _parsePnpmDependencyKey;
     private _serializeInternal;
+    private _getIndividualShrinkwrapImporter;
 }
 //# sourceMappingURL=PnpmShrinkwrapFile.d.ts.map

package/lib/logic/pnpm/SplitWorkspaceGlobalPnpmfileShim.d.ts

@@ -0,0 +1,3 @@
+import type { IPnpmfileHooks } from './IPnpmfile';
+export declare const hooks: IPnpmfileHooks;
+//# sourceMappingURL=SplitWorkspaceGlobalPnpmfileShim.d.ts.map

package/lib/logic/pnpm/SplitWorkspaceGlobalPnpmfileShim.js

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

package/lib/logic/pnpm/SplitWorkspacePnpmfileConfiguration.d.ts

@@ -0,0 +1,23 @@
+import { IPackageJson } from '@rushstack/node-core-library';
+import type { RushConfiguration } from '../../api/RushConfiguration';
+/**
+ * Loads PNPM's pnpmfile.js configuration, and invokes it to preprocess package.json files,
+ * optionally utilizing a pnpmfile shim to inject preferred versions.
+ */
+export declare class SplitWorkspacePnpmfileConfiguration {
+    private _context;
+    constructor(rushConfiguration: RushConfiguration);
+    /**
+     * Split workspace use global pnpmfile, because in split workspace, user may set `shared-workspace-lockfile=false`.
+     * That means each project owns their individual pnpmfile under project folder. While the global pnpmfile could be
+     * under the common/temp-split/ folder and be used by all split workspace projects.
+     */
+    static writeCommonTempSplitGlobalPnpmfileAsync(rushConfiguration: RushConfiguration): Promise<void>;
+    private static _getSplitWorkspacePnpmfileShimSettings;
+    /**
+     * Transform a package.json file using the pnpmfile.js hook.
+     * @returns the tranformed object, or the original input if pnpmfile.js was not found.
+     */
+    transform(packageJson: IPackageJson): IPackageJson;
+}
+//# sourceMappingURL=SplitWorkspacePnpmfileConfiguration.d.ts.map