@pnpm/installing.deps-installer 1100.0.2 → 1100.0.3

package/lib/install/extendInstallOptions.d.ts

@@ -151,6 +151,8 @@ export interface StrictInstallOptions {
     trustPolicyIgnoreAfter?: number;
     packageVulnerabilityAudit?: PackageVulnerabilityAudit;
     blockExoticSubdeps?: boolean;
+    /** URL of a pnpm agent server. See the pnpm-agent README. */
+    agent?: string;
 }
 export type InstallOptions = Partial<StrictInstallOptions> & Pick<StrictInstallOptions, 'storeDir' | 'storeController'>;
 export interface ProcessedInstallOptions extends StrictInstallOptions {

package/lib/install/index.js

@@ -15,14 +15,15 @@ import { getContext } from '@pnpm/installing.context';
 import { getWantedDependencies, resolveDependencies, } from '@pnpm/installing.deps-resolver';
 import { extendProjectsWithTargetDirs, headlessInstall } from '@pnpm/installing.deps-restorer';
 import { writeModulesManifest } from '@pnpm/installing.modules-yaml';
-import { cleanGitBranchLockfiles, writeCurrentLockfile, writeLockfiles, writeWantedLockfile, } from '@pnpm/lockfile.fs';
+import { cleanGitBranchLockfiles, readWantedLockfile, writeCurrentLockfile, writeLockfiles, writeWantedLockfile, } from '@pnpm/lockfile.fs';
 import { getPreferredVersionsFromLockfileAndManifests } from '@pnpm/lockfile.preferred-versions';
 import { calcPatchHashes, createOverridesMapFromParsed, getOutdatedLockfileSetting, } from '@pnpm/lockfile.settings-checker';
 import { writePnpFile } from '@pnpm/lockfile.to-pnp';
 import { allProjectsAreUpToDate, satisfiesPackageManifest } from '@pnpm/lockfile.verification';
 import { globalInfo, logger, streamParser } from '@pnpm/logger';
 import { groupPatchedDependencies } from '@pnpm/patching.config';
-import { getAllDependenciesFromManifest, getAllUniqueSpecs } from '@pnpm/pkg-manifest.utils';
+import { createVersionSpecFromResolvedVersion, getAllDependenciesFromManifest, getAllUniqueSpecs } from '@pnpm/pkg-manifest.utils';
+import { parseWantedDependency } from '@pnpm/resolving.parse-wanted-dependency';
 import { lexCompare } from '@pnpm/util.lex-comparator';
 import { safeReadProjectManifestOnly } from '@pnpm/workspace.project-manifest-reader';
 import { isSubdir } from 'is-subdir';
@@ -51,6 +52,11 @@ const BROKEN_LOCKFILE_INTEGRITY_ERRORS = new Set([
 const DEV_PREINSTALL = 'pnpm:devPreinstall';
 export async function install(manifest, opts) {
     const rootDir = (opts.dir ?? process.cwd());
+    // When a pnpm agent is configured, use server-side resolution
+    // instead of the normal resolution flow.
+    if (opts.agent) {
+        return installFromPnpmRegistry(manifest, rootDir, opts);
+    }
     const { updatedCatalogs, updatedProjects: projects, ignoredBuilds } = await mutateModules([
         {
             mutation: 'install',
@@ -105,6 +111,15 @@ export async function mutateModules(projects, maybeOpts) {
         streamParser.on('data', reporter);
     }
     const opts = extendOptions(maybeOpts);
+    // When a pnpm agent is configured, use server-side resolution. The agent
+    // path supports `install`, `installSome` (pnpm add), and `uninstallSome`
+    // (pnpm remove). Mutations that need full client-side resolution (update
+    // flags) still fall through to the normal flow.
+    if (opts.agent && canUseAgentForMutations(projects)) {
+        const agentResult = await mutateModulesViaAgent(projects, opts);
+        if (agentResult)
+            return agentResult;
+    }
     const allowBuild = createAllowBuildFunction(opts);
     if (!opts.include.dependencies && opts.include.optionalDependencies) {
         throw new PnpmError('OPTIONAL_DEPS_REQUIRE_PROD_DEPS', 'Optional dependencies cannot be installed without production dependencies');
@@ -1005,6 +1020,7 @@ const _installInContext = async (projects, ctx, opts) => {
             wantedToBeSkippedPackageIds,
             hoistWorkspacePackages: opts.hoistWorkspacePackages,
             virtualStoreOnly: opts.virtualStoreOnly,
+            supportedArchitectures: opts.supportedArchitectures,
         });
         stats = result.stats;
         if (opts.enablePnp) {
@@ -1374,4 +1390,356 @@ function getProjectsWithTargetDirs(projects, lockfile, dependenciesGraph) {
     }
     return extendProjectsWithTargetDirs(projects, injectionTargetsByDepPath);
 }
+/**
+ * Whether the agent path can handle this batch of mutations. The agent flow
+ * supports installing the manifest as-is (`install`), adding new deps
+ * (`installSome`), and removing deps (`uninstallSome`). It cannot model the
+ * client-side update-flag behavior (`update`/`updateMatching`/`updateToLatest`)
+ * yet, so those still go through the normal client-side resolver.
+ */
+function canUseAgentForMutations(projects) {
+    if (projects.length === 0)
+        return false;
+    return projects.every((p) => {
+        if (p.mutation === 'uninstallSome')
+            return true;
+        if (p.mutation !== 'install' && p.mutation !== 'installSome')
+            return false;
+        const m = p;
+        return !m.update && !m.updateToLatest && m.updateMatching == null;
+    });
+}
+/**
+ * Pre-process projects for the agent flow:
+ * - `install`: send the manifest as-is.
+ * - `uninstallSome`: drop the named deps from the manifest before sending,
+ *   so the agent's resolution naturally produces a lockfile without them.
+ * - `installSome`: parse selectors and merge them into the manifest. The
+ *   agent server then resolves the merged manifest, and we read the resolved
+ *   specifiers (with the right save-prefix applied server-side) back from
+ *   the lockfile importer entries to update the client-side manifest.
+ *
+ * Returns null if the projects don't map cleanly to allProjects (caller
+ * should fall through to the normal flow).
+ */
+async function prepareAgentProjects(projects, opts) {
+    const allProjects = opts.allProjects ?? [];
+    const mutationByRootDir = new Map();
+    for (const p of projects) {
+        mutationByRootDir.set(p.rootDir, p);
+    }
+    // Include every workspace project, not just the mutated ones — otherwise
+    // the agent's resulting lockfile would only contain the targeted importer
+    // and `headlessInstall` (or a later install) would crash on the missing
+    // entries for the other workspace projects. Projects without a mutation
+    // are sent with their current manifest (no-op for resolution).
+    const targetSet = allProjects.length > 0
+        ? allProjects.map((ap) => ({
+            rootDir: ap.rootDir,
+            manifest: ap.manifest,
+            mutation: mutationByRootDir.get(ap.rootDir),
+        }))
+        : projects.map((p) => {
+            const proj = allProjects.find((ap) => ap.rootDir === p.rootDir);
+            return {
+                rootDir: p.rootDir,
+                manifest: proj?.manifest ?? {},
+                mutation: p,
+            };
+        });
+    // Bail to the normal flow if any mutated project isn't in allProjects —
+    // we can't pre-process its manifest correctly.
+    for (const p of projects) {
+        if (!targetSet.some((t) => t.rootDir === p.rootDir))
+            return null;
+    }
+    return Promise.all(targetSet.map(async (t) => {
+        let manifest = clone(t.manifest);
+        const newDeps = [];
+        const mutation = t.mutation;
+        let pinnedVersion;
+        if (mutation?.mutation === 'uninstallSome') {
+            manifest = await removeDeps(manifest, mutation.dependencyNames, {
+                prefix: mutation.rootDir,
+                saveType: mutation.targetDependenciesField,
+            });
+        }
+        else if (mutation?.mutation === 'installSome') {
+            manifest = mergeInstallSelectors(manifest, mutation);
+            pinnedVersion = mutation.pinnedVersion;
+            for (const sel of mutation.dependencySelectors) {
+                const parsed = parseWantedDependency(sel);
+                if (parsed.alias) {
+                    newDeps.push({ alias: parsed.alias, userSpecified: parsed.bareSpecifier != null });
+                }
+            }
+        }
+        return {
+            rootDir: t.rootDir,
+            manifest,
+            mutation: mutation?.mutation ?? 'install',
+            newDeps,
+            pinnedVersion,
+        };
+    }));
+}
+/**
+ * Merge `installSome` selectors into the manifest, choosing the target
+ * dependency field per the mutation's `targetDependenciesField` (or the
+ * existing field if the dep is already in the manifest, defaulting to
+ * `dependencies`). Selectors without a version use `'latest'` so the
+ * agent's resolver picks the newest matching release.
+ */
+function mergeInstallSelectors(manifest, mutation) {
+    const target = mutation.targetDependenciesField;
+    const fieldsToClear = ['dependencies', 'devDependencies', 'optionalDependencies'];
+    for (const sel of mutation.dependencySelectors) {
+        const parsed = parseWantedDependency(sel);
+        if (!parsed.alias)
+            continue;
+        const alias = parsed.alias;
+        const field = target ?? guessDepField(alias, manifest) ?? 'dependencies';
+        const spec = parsed.bareSpecifier ?? findExistingSpec(alias, manifest) ?? 'latest';
+        manifest[field] = manifest[field] ?? {};
+        manifest[field][alias] = spec;
+        // If `targetDependenciesField` is set, also remove the alias from the
+        // other fields — matches the normal flow's behavior.
+        if (target) {
+            for (const other of fieldsToClear) {
+                if (other !== target)
+                    delete manifest[other]?.[alias];
+            }
+        }
+        if (mutation.peer) {
+            manifest.peerDependencies = manifest.peerDependencies ?? {};
+            manifest.peerDependencies[alias] = manifest.peerDependencies[alias] ?? spec;
+        }
+    }
+    return manifest;
+}
+function guessDepField(alias, manifest) {
+    if (manifest.dependencies?.[alias] != null)
+        return 'dependencies';
+    if (manifest.devDependencies?.[alias] != null)
+        return 'devDependencies';
+    if (manifest.optionalDependencies?.[alias] != null)
+        return 'optionalDependencies';
+    return undefined;
+}
+function findExistingSpec(alias, manifest) {
+    return manifest.dependencies?.[alias] ??
+        manifest.devDependencies?.[alias] ??
+        manifest.optionalDependencies?.[alias];
+}
+/**
+ * After the agent resolves, copy the lockfile importer's per-dep specifier
+ * (which the server's resolver computed with the right save-prefix) back
+ * into the client manifest for any newly added aliases. We rely on the
+ * lockfile because the agent server applies catalog substitution,
+ * normalizedBareSpecifier, and save-prefix logic during resolution.
+ */
+function applyResolvedSpecsFromLockfile(manifest, importerSnapshot, newDeps, pinnedVersion) {
+    if (!importerSnapshot || newDeps.length === 0)
+        return manifest;
+    // In-memory ProjectSnapshot stores resolved versions in `dependencies`
+    // (alias → resolved version) and original specs in `specifiers` (alias →
+    // user spec). The on-disk YAML shape pairs them per entry — the reader
+    // splits them. Read both and compute the save-prefix spec client-side.
+    for (const dep of newDeps) {
+        // User explicitly specified a spec (e.g. `foo@^2`) — the merged manifest
+        // already has the right value, don't touch it.
+        if (dep.userSpecified)
+            continue;
+        for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+            const resolvedVersion = importerSnapshot[field]?.[dep.alias];
+            if (!resolvedVersion || manifest[field]?.[dep.alias] == null)
+                continue;
+            // The agent server resolved the tree but, on the plain-install path, it
+            // writes the user's raw spec (`'latest'`) into the lockfile specifier
+            // rather than normalizing to a save-prefix range. Compute the
+            // save-prefix spec client-side from the resolved version.
+            const savePrefixSpec = createVersionSpecFromResolvedVersion(resolvedVersion, pinnedVersion);
+            manifest[field][dep.alias] = savePrefixSpec ?? resolvedVersion;
+        }
+    }
+    return manifest;
+}
+/**
+ * Drives the agent path for a `mutateModules` call across one or more
+ * projects. Returns null if the call can't be served by the agent (e.g. one
+ * of the projects isn't in `allProjects`).
+ */
+async function mutateModulesViaAgent(projects, opts) {
+    const agentProjects = await prepareAgentProjects(projects, opts);
+    if (!agentProjects)
+        return null;
+    // installFromPnpmRegistry runs the headless install for the first
+    // project's root and the workspace path for the rest. Pass the
+    // pre-processed manifests so resolution sees the post-mutation state.
+    const result = await installFromPnpmRegistry(agentProjects[0].manifest, agentProjects[0].rootDir, opts, agentProjects.map((p) => ({ rootDir: p.rootDir, manifest: p.manifest })));
+    // For installSome projects, copy resolved specs from the lockfile importer
+    // entries back into the client manifest so save-prefix/catalog/etc. take
+    // effect (the server applies these during its resolution step).
+    const lockfileDir = opts.lockfileDir ?? projects[0].rootDir;
+    const mutatedRootDirs = new Set(projects.map((p) => p.rootDir));
+    const updatedProjects = agentProjects
+        .filter((p) => mutatedRootDirs.has(p.rootDir))
+        .map((p) => {
+        if (p.mutation === 'installSome' && p.newDeps.length > 0) {
+            // Lockfile importer keys are POSIX-normalized paths.
+            const relative = path.relative(lockfileDir, p.rootDir).split(path.sep).join('/');
+            const importerId = (relative || '.');
+            const snapshot = result.lockfile?.importers?.[importerId];
+            p.manifest = applyResolvedSpecsFromLockfile(p.manifest, snapshot, p.newDeps, p.pinnedVersion);
+        }
+        return { rootDir: p.rootDir, manifest: p.manifest };
+    });
+    return {
+        updatedProjects,
+        stats: result.stats,
+        ignoredBuilds: result.ignoredBuilds,
+    };
+}
+/**
+ * When a pnpm agent is configured, resolve dependencies server-side
+ * and download only the missing files. Then run a headless install to link
+ * packages into node_modules.
+ */
+async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjects) {
+    const { fetchFromPnpmRegistry } = await import('@pnpm/agent.client');
+    const { StoreIndex } = await import('@pnpm/store.index');
+    const { setImportConcurrency } = await import('@pnpm/worker');
+    // Raise import concurrency for this install only — the agent path has no
+    // concurrent fetching competing for workers. Restore afterwards so we
+    // don't leak a process-wide mutation to other installs (e.g. tests).
+    const restoreImportConcurrency = setImportConcurrency(6);
+    try {
+        const lockfileDir = opts.lockfileDir ?? rootDir;
+        // Read existing lockfile if available
+        const existingLockfile = await readWantedLockfile(lockfileDir, {
+            ignoreIncompatible: true,
+        }).catch(() => null);
+        logger.info({ message: 'Resolving dependencies via pnpm agent', prefix: rootDir });
+        // Open the store index to read integrities and write new entries.
+        // Close it in a finally so a failure in fetchFromPnpmRegistry doesn't
+        // leak an open SQLite handle (on Windows that also blocks store cleanup).
+        const storeIndex = new StoreIndex(opts.storeDir);
+        let lockfile, agentStats, fileDownloads, indexEntries;
+        try {
+            // Build projects list for workspace support.
+            // Normalize separators to POSIX — on Windows `path.relative` returns
+            // backslashes, which the agent server rejects (it treats `\` as an
+            // unsafe/YAML-injection character and normalizes paths as POSIX).
+            const projectsList = allInstallProjects && allInstallProjects.length > 1
+                ? allInstallProjects.map(p => ({
+                    dir: (path.relative(lockfileDir, p.rootDir) || '.').split(path.sep).join('/'),
+                    dependencies: p.manifest.dependencies,
+                    devDependencies: p.manifest.devDependencies,
+                }))
+                : undefined;
+            ({ lockfile, stats: agentStats, fileDownloads, indexEntries } = await fetchFromPnpmRegistry({
+                registryUrl: opts.agent,
+                storeDir: opts.storeDir,
+                storeIndex,
+                dependencies: projectsList ? undefined : manifest.dependencies,
+                devDependencies: projectsList ? undefined : manifest.devDependencies,
+                projects: projectsList,
+                overrides: opts.overrides,
+                minimumReleaseAge: opts.minimumReleaseAge,
+                lockfile: existingLockfile ?? undefined,
+            }));
+            // Write store index entries so headless install finds them.
+            const { writeRawIndexEntries } = await import('@pnpm/agent.client');
+            writeRawIndexEntries(indexEntries, storeIndex);
+            storeIndex.checkpoint();
+        }
+        finally {
+            storeIndex.close();
+        }
+        await writeWantedLockfile(lockfileDir, lockfile);
+        logger.info({
+            message: `Resolved ${agentStats.totalPackages} packages: ${agentStats.alreadyInStore} cached, ${agentStats.filesToDownload} files to download`,
+            prefix: rootDir,
+        });
+        // Wrap fetchPackage to:
+        // 1. Wait for agent file downloads before checking the store
+        // 2. Skip integrity verification — files just written from the agent
+        //    are guaranteed correct (server verified, no rehashing needed)
+        const { readPkgFromCafs } = await import('@pnpm/worker');
+        const { storeIndexKey: _storeIndexKey } = await import('@pnpm/store.index');
+        const wrappedStoreController = {
+            ...opts.storeController,
+            fetchPackage: async (fetchOpts) => {
+                await fileDownloads;
+                const resolution = fetchOpts.pkg.resolution;
+                const integrity = resolution?.integrity;
+                if (integrity) {
+                    const filesIndexFile = _storeIndexKey(integrity, fetchOpts.pkg.id);
+                    const result = await readPkgFromCafs({ storeDir: opts.storeDir, verifyStoreIntegrity: false }, filesIndexFile, { readManifest: true, expectedPkg: { name: fetchOpts.pkg.name, version: fetchOpts.pkg.version } });
+                    return {
+                        fetching: () => Promise.resolve({
+                            files: result.files,
+                            bundledManifest: result.bundledManifest,
+                            integrity,
+                        }),
+                        filesIndexFile,
+                    };
+                }
+                return opts.storeController.fetchPackage(fetchOpts);
+            },
+        };
+        const headlessOpts = {
+            ...opts,
+            // Skip re-verifying files just written from the agent — they're
+            // guaranteed correct (server verified, no rehashing needed).
+            verifyStoreIntegrity: false,
+            storeController: wrappedStoreController,
+            dir: rootDir,
+            lockfileDir,
+            engineStrict: opts.engineStrict ?? false,
+            ignoreScripts: opts.ignoreScripts ?? false,
+            sideEffectsCacheRead: opts.sideEffectsCacheRead ?? false,
+            sideEffectsCacheWrite: opts.sideEffectsCacheWrite ?? false,
+            symlink: opts.symlink ?? true,
+            enableModulesDir: opts.enableModulesDir ?? true,
+            include: opts.include ?? { dependencies: true, devDependencies: true, optionalDependencies: true },
+            currentEngine: {
+                nodeVersion: opts.nodeVersion,
+                pnpmVersion: opts.packageManager?.version ?? '',
+            },
+            selectedProjectDirs: (allInstallProjects ?? [{ rootDir }]).map(p => p.rootDir),
+            allProjects: Object.fromEntries((allInstallProjects ?? [{ rootDir, manifest }]).map((p, i) => [
+                p.rootDir,
+                {
+                    binsDir: path.join(p.rootDir, 'node_modules', '.bin'),
+                    buildIndex: i,
+                    id: (path.relative(lockfileDir, p.rootDir) || '.'),
+                    manifest: p.manifest,
+                    modulesDir: path.join(p.rootDir, 'node_modules'),
+                    rootDir: p.rootDir,
+                },
+            ])),
+            hoistedDependencies: {},
+            pendingBuilds: [],
+            skipped: new Set(),
+            wantedLockfile: lockfile,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { ignoredBuilds, stats } = await headlessInstall(headlessOpts);
+        return {
+            updatedCatalogs: undefined,
+            updatedManifest: manifest,
+            ignoredBuilds,
+            stats,
+            lockfile,
+        };
+    }
+    finally {
+        // Close the storeController to flush queued StoreIndex writes — the
+        // normal install path does the same; skipping it here would leave
+        // pending writes on disk and diverge from lifecycle expectations.
+        await opts.storeController.close();
+        restoreImportConcurrency();
+    }
+}
 //# sourceMappingURL=index.js.map

package/lib/install/link.d.ts

@@ -4,7 +4,7 @@ import type { InstallationResultStats } from '@pnpm/installing.deps-restorer';
 import type { IncludedDependencies } from '@pnpm/installing.modules-yaml';
 import type { LockfileObject } from '@pnpm/lockfile.fs';
 import type { StoreController } from '@pnpm/store.controller-types';
-import type { AllowBuild, DepPath, HoistedDependencies, Registries } from '@pnpm/types';
+import type { AllowBuild, DepPath, HoistedDependencies, Registries, SupportedArchitectures } from '@pnpm/types';
 import type { ImporterToUpdate } from './index.js';
 export interface LinkPackagesOptions {
     allowBuild?: AllowBuild;
@@ -40,6 +40,7 @@ export interface LinkPackagesOptions {
     wantedToBeSkippedPackageIds: Set<string>;
     hoistWorkspacePackages?: boolean;
     virtualStoreOnly: boolean;
+    supportedArchitectures?: SupportedArchitectures;
 }
 export interface LinkPackagesResult {
     currentLockfile: LockfileObject;

package/lib/install/link.js

@@ -83,6 +83,7 @@ export async function linkPackages(projects, depGraph, opts) {
         symlink: opts.symlink,
         skipped: opts.skipped,
         storeController: opts.storeController,
+        supportedArchitectures: opts.supportedArchitectures,
         virtualStoreDir: opts.virtualStoreDir,
     });
     stageLogger.debug({
@@ -284,6 +285,7 @@ async function linkNewPackages(currentLockfile, wantedLockfile, depGraph, opts)
             ignoreScripts: opts.ignoreScripts,
             lockfileDir: opts.lockfileDir,
             sideEffectsCacheRead: opts.sideEffectsCacheRead,
+            supportedArchitectures: opts.supportedArchitectures,
         }),
     ]);
     return { newDepPaths, added };
@@ -323,6 +325,7 @@ async function linkAllPkgs(storeController, depNodes, opts) {
                 sideEffectsCacheKey = calcDepState(opts.depGraph, opts.depsStateCache, depNode.depPath, {
                     includeDepGraphHash: !opts.ignoreScripts && depNode.requiresBuild, // true when is built
                     patchFileHash: depNode.patch?.hash,
+                    supportedArchitectures: opts.supportedArchitectures,
                 });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/installing.deps-installer",
-  "version": "1100.0.2",
+  "version": "1100.0.3",
   "description": "Fast, disk space efficient installation engine",
   "keywords": [
     "pnpm",
@@ -61,58 +61,60 @@
     "ramda": "npm:@pnpm/ramda@0.28.1",
     "run-groups": "^5.0.0",
     "semver": "^7.7.2",
-    "@pnpm/building.after-install": "1100.0.2",
+    "@pnpm/agent.client": "0.0.1",
+    "@pnpm/bins.remover": "1100.0.1",
+    "@pnpm/building.after-install": "1100.0.3",
+    "@pnpm/building.during-install": "1100.0.3",
     "@pnpm/bins.linker": "1100.0.2",
     "@pnpm/building.policy": "1100.0.1",
-    "@pnpm/building.during-install": "1100.0.2",
-    "@pnpm/bins.remover": "1100.0.1",
     "@pnpm/catalogs.protocol-parser": "1100.0.0",
-    "@pnpm/config.matcher": "1100.0.0",
-    "@pnpm/catalogs.types": "1100.0.0",
-    "@pnpm/config.normalize-registries": "1100.0.1",
     "@pnpm/catalogs.resolver": "1100.0.0",
+    "@pnpm/config.matcher": "1100.0.0",
     "@pnpm/config.parse-overrides": "1100.0.0",
+    "@pnpm/config.normalize-registries": "1100.0.1",
+    "@pnpm/catalogs.types": "1100.0.0",
     "@pnpm/constants": "1100.0.0",
     "@pnpm/crypto.hash": "1100.0.0",
+    "@pnpm/core-loggers": "1100.0.1",
     "@pnpm/crypto.object-hasher": "1100.0.0",
-    "@pnpm/deps.graph-hasher": "1100.0.1",
+    "@pnpm/deps.graph-hasher": "1100.1.0",
     "@pnpm/deps.graph-sequencer": "1100.0.0",
-    "@pnpm/core-loggers": "1100.0.1",
     "@pnpm/deps.path": "1100.0.1",
-    "@pnpm/error": "1100.0.0",
+    "@pnpm/exec.lifecycle": "1100.0.3",
     "@pnpm/fs.read-modules-dir": "1100.0.0",
     "@pnpm/fs.symlink-dependency": "1100.0.1",
-    "@pnpm/exec.lifecycle": "1100.0.2",
+    "@pnpm/hooks.types": "1100.0.2",
+    "@pnpm/error": "1100.0.0",
     "@pnpm/hooks.read-package-hook": "1100.0.1",
-    "@pnpm/installing.context": "1100.0.1",
-    "@pnpm/hooks.types": "1100.0.1",
-    "@pnpm/installing.deps-resolver": "1100.0.2",
-    "@pnpm/installing.linking.direct-dep-linker": "1100.0.1",
-    "@pnpm/installing.deps-restorer": "1100.0.2",
+    "@pnpm/installing.context": "1100.0.2",
+    "@pnpm/installing.deps-resolver": "1100.0.3",
+    "@pnpm/installing.deps-restorer": "1100.0.3",
     "@pnpm/installing.linking.hoist": "1100.0.2",
-    "@pnpm/installing.linking.modules-cleaner": "1100.0.1",
-    "@pnpm/installing.package-requester": "1100.0.1",
-    "@pnpm/lockfile.filtering": "1100.0.1",
-    "@pnpm/lockfile.fs": "1100.0.1",
-    "@pnpm/lockfile.preferred-versions": "1100.0.2",
+    "@pnpm/installing.linking.modules-cleaner": "1100.0.2",
+    "@pnpm/installing.linking.direct-dep-linker": "1100.0.1",
     "@pnpm/installing.modules-yaml": "1100.0.1",
-    "@pnpm/lockfile.to-pnp": "1100.0.1",
-    "@pnpm/lockfile.pruner": "1100.0.1",
-    "@pnpm/lockfile.utils": "1100.0.1",
-    "@pnpm/lockfile.walker": "1100.0.1",
-    "@pnpm/lockfile.settings-checker": "1100.0.1",
+    "@pnpm/lockfile.filtering": "1100.0.2",
+    "@pnpm/lockfile.fs": "1100.0.2",
+    "@pnpm/lockfile.preferred-versions": "1100.0.3",
+    "@pnpm/lockfile.settings-checker": "1100.0.2",
+    "@pnpm/lockfile.pruner": "1100.0.2",
+    "@pnpm/installing.package-requester": "1100.0.2",
+    "@pnpm/lockfile.to-pnp": "1100.0.2",
+    "@pnpm/lockfile.utils": "1100.0.2",
+    "@pnpm/lockfile.walker": "1100.0.2",
     "@pnpm/patching.config": "1100.0.1",
-    "@pnpm/lockfile.verification": "1100.0.1",
-    "@pnpm/pkg-manifest.utils": "1100.1.0",
+    "@pnpm/resolving.resolver-base": "1100.1.0",
+    "@pnpm/lockfile.verification": "1100.0.2",
     "@pnpm/resolving.parse-wanted-dependency": "1100.0.0",
-    "@pnpm/resolving.resolver-base": "1100.0.1",
+    "@pnpm/store.controller-types": "1100.0.2",
+    "@pnpm/pkg-manifest.utils": "1100.1.0",
+    "@pnpm/store.index": "1100.0.0",
     "@pnpm/types": "1101.0.0",
-    "@pnpm/workspace.project-manifest-reader": "1100.0.2",
-    "@pnpm/store.controller-types": "1100.0.1"
+    "@pnpm/workspace.project-manifest-reader": "1100.0.2"
   },
   "peerDependencies": {
     "@pnpm/logger": ">=1001.0.0 <1002.0.0",
-    "@pnpm/worker": "^1100.0.1"
+    "@pnpm/worker": "^1100.0.2"
   },
   "devDependencies": {
     "@jest/globals": "30.3.0",
@@ -135,22 +137,21 @@
     "symlink-dir": "^10.0.1",
     "write-json-file": "^7.0.0",
     "write-yaml-file": "^6.0.0",
-    "@pnpm/assert-project": "1100.0.1",
-    "@pnpm/installing.deps-installer": "1100.0.2",
-    "@pnpm/assert-store": "1100.0.1",
-    "@pnpm/lockfile.types": "1100.0.1",
+    "@pnpm/assert-project": "1100.0.2",
+    "@pnpm/installing.deps-installer": "1100.0.3",
+    "@pnpm/assert-store": "1100.0.2",
     "@pnpm/logger": "1100.0.0",
+    "@pnpm/lockfile.types": "1100.0.2",
+    "@pnpm/prepare": "1100.0.2",
+    "@pnpm/resolving.registry.types": "1100.0.1",
     "@pnpm/network.git-utils": "1100.0.0",
-    "@pnpm/prepare": "1100.0.1",
     "@pnpm/pkg-manifest.reader": "1100.0.1",
-    "@pnpm/store.cafs": "1100.0.1",
-    "@pnpm/store.index": "1100.0.0",
-    "@pnpm/test-fixtures": "1100.0.0",
-    "@pnpm/resolving.registry.types": "1100.0.1",
+    "@pnpm/store.cafs": "1100.0.2",
     "@pnpm/store.path": "1100.0.0",
     "@pnpm/test-ipc-server": "1100.0.0",
-    "@pnpm/testing.temp-store": "1100.0.2",
-    "@pnpm/testing.mock-agent": "1100.0.1"
+    "@pnpm/test-fixtures": "1100.0.0",
+    "@pnpm/testing.mock-agent": "1100.0.1",
+    "@pnpm/testing.temp-store": "1100.0.3"
   },
   "engines": {
     "node": ">=22.13"