pnpm 12.15.0 → 12.16.0

package/CHANGELOG.md

@@ -1,5 +1,194 @@
 # pnpm
 
+## 12.16.0
+
+This release adds a global `--env-file` flag, updates to a symlinked `pnpm-lock.yaml`, and `pnpm setup --no-modify-path`. It also fixes two security issues, in zstd decompression and in signing.
+
+### Minor Changes
+
+- Added a repeatable global `--env-file <path>` flag to load environment variables from dotenv-style files before running a command. Later files override earlier files, variables already in the environment are preserved, and loaded variables are visible to user-level `.npmrc` interpolation and lifecycle scripts [#7111](https://github.com/pnpm/pnpm/issues/7111).
+
+- pnpm can now update a `pnpm-lock.yaml` that is a symlink. List the directories the lockfile may link into in the `symlinkedLockfileTargetDirs` setting, in the global config or with `PNPM_CONFIG_SYMLINKED_LOCKFILE_TARGET_DIRS`. pnpm writes the update to the file the symlink points to if that file is inside one of these directories. The symlink stays in place. pnpm ignores this setting in `pnpm-workspace.yaml` [#17222](https://github.com/pnpm/pnpm/issues/17222).
+
+- Added a `--no-modify-path` option to `pnpm setup`. It installs pnpm without adding it to `PATH`, leaving the shell config file, the Windows registry, and the GitHub Actions environment files unchanged. `pnpm setup` then prints the lines to add yourself [get.pnpm.io#37](https://github.com/pnpm/get.pnpm.io/issues/37).
+
+### Patch Changes
+
+#### Security
+
+- Fixed memory exposure and allocation handling vulnerabilities when processing zstd-compressed data [#17388](https://github.com/pnpm/pnpm/pull/17388).
+
+- Signing in pnpm and pnpr no longer uses arithmetic that may leak the private key through timing. This covers shared artifacts, OCI registry tokens, and OIDC login state [advisory](https://rustsec.org/advisories/RUSTSEC-2026-0387).
+
+#### Installing packages
+
+- A dependency symlink that pnpm cannot point at the wanted target now fails the install with an error that names the link. This happens when the filesystem still serves the old link after pnpm removed it, as a `node_modules` served by a virtual filesystem does. pnpm used to remove the link again without end and crashed with a segmentation fault once the thread ran out of stack.
+
+- Concurrent workspace installs no longer lose store-index rows when initializing the shared SQLite index [#17388](https://github.com/pnpm/pnpm/pull/17388).
+
+- Agent skill links now keep the same target across installs when a package version is installed with several sets of peer dependencies. An install no longer fails with `ERR_PNPM_AGENT_SKILL_PATH_OCCUPIED` on a skill link that pnpm created for another of those copies [#17319](https://github.com/pnpm/pnpm/issues/17319).
+
+- pnpm now fails at once, without retrying, when a downloaded package archive contains a rejected entry path [#17205](https://github.com/pnpm/pnpm/issues/17205).
+
+- pnpm now builds a git-hosted dependency in every new location it links the dependency into, such as a new global virtual store slot or a fresh `node_modules`. When the side-effects cache holds the build output, pnpm restores it from there. Before, only the install that fetched the dependency built it. This also fixes dependencies that are already in the store [#17224](https://github.com/pnpm/pnpm/issues/17224).
+
+- Changes a `preResolution` hook makes to the lockfiles now take effect. The hook now also runs when pnpm installs from an up-to-date lockfile. An error thrown by the hook now fails the install.
+
+- A custom fetcher in the pnpmfile can now call `fetchers.directory` to fetch a package from a local directory. The call rejects with `ERR_PNPM_TARBALL_INTEGRITY` if the lockfile pins an archive integrity for the package. Previously, calling `fetchers.directory` failed with a `TypeError`.
+
+- `packageImportMethod: copy` now also applies to packages that have lifecycle scripts or patches. On a filesystem that supports block cloning, such as ReFS or a Dev Drive on Windows, these packages were cloned [#17195](https://github.com/pnpm/pnpm/issues/17195).
+
+- With `nodeLinker: hoisted` and `autoInstallPeers: false`, a package that workspace projects use with different peer versions is now installed once per peer variant, so each project's copy resolves that project's peer [#17395](https://github.com/pnpm/pnpm/issues/17395).
+
+- Under `nodeLinker: hoisted`, `pnpm install` now leaves a patched package that is already in place alone. The same holds for a package whose peers include a patched package, such as every package peering on a patched `react-native` [#17188](https://github.com/pnpm/pnpm/issues/17188).
+
+- With `nodeLinker: hoisted`, an install that stops partway no longer leaves the next install trusting the packages it was replacing. Before, reverting the change that started the stopped install, such as a patch edit, kept the half-replaced package in `node_modules`.
+
+#### Repeat installs and changed settings
+
+- A repeat `pnpm install` now acts on a change to these settings. Before, it reported "Already up to date".
+
+  - `storeDir` or `virtualStoreDir`: it recreates `node_modules`.
+  - `globalVirtualStoreDir`: it links the packages from the new directory.
+  - `virtualStoreDirMaxLength`: it renames the virtual store directories.
+  - `dangerouslyAllowAllBuilds` turned on: it runs the builds it skipped.
+  - `trustLockfile` turned off: it verifies the lockfile.
+
+- `pnpm add`, `pnpm remove`, and `pnpm update` now fail if `node_modules` does not match the current settings. Run `pnpm install` to recreate it. Previously, these commands removed and reinstalled `node_modules` without asking. They report:
+
+  - `ERR_PNPM_UNEXPECTED_STORE` if `node_modules` was linked from a different store.
+  - `ERR_PNPM_UNEXPECTED_VIRTUAL_STORE` if it was linked from a different virtual store directory.
+  - `ERR_PNPM_MODULES_BREAKING_CHANGE` if it was installed by an incompatible pnpm version, or if `node_modules/.modules.yaml` cannot be read.
+  - `ERR_PNPM_NODE_LINKER_DIFF` if it was installed with a different `nodeLinker`.
+
+  `pnpm update` now also fails with `ERR_PNPM_HOIST_PATTERN_DIFF` and the other errors `pnpm add` reports for a changed hoist pattern or `virtualStoreDirMaxLength`.
+
+- An install filtered to some workspace projects now fails if `node_modules` was installed with a different `nodeLinker`, `hoistPattern`, `publicHoistPattern`, store, or virtual store. Before, it recreated `node_modules` and left the projects it skipped without their dependencies. A `pnpm install` of the whole workspace still recreates `node_modules` [pnpm/tasks#217](https://github.com/pnpm/tasks/issues/217).
+
+- `pnpm install` and the `verifyDepsBeforeRun` check now notice an edited patch file when `sharedWorkspaceLockfile` is `false`.
+
+- `pnpm install` now takes its fast path in a workspace with `patchedDependencies` when the previous install ran with another major version of pnpm.
+
+- `pnpm install` now relinks the bins of a workspace package when its `bin` field changes, including with `--frozen-lockfile` and an unchanged lockfile. A filtered install relinks them in the selected projects, and the next install that covers the remaining projects relinks them there [#17324](https://github.com/pnpm/pnpm/issues/17324).
+
+- `pnpm install` now removes command shims from `node_modules/.bin` when a workspace dependency renames or removes an entry from its `bin` field [pnpm/tasks#211](https://github.com/pnpm/tasks/issues/211).
+
+#### Resolving dependencies and the lockfile
+
+- A package that a plain range and a `<prefix>:` specifier both resolve from one registry is now recorded once in `pnpm-lock.yaml` and installed once. The lockfile key names the registry a package resolved from. When that registry declares a prefix, through `prefix` in `registries` or through `namedRegistries`, the package is keyed `<name>@<prefix>:<version>` however its dependency was written: with the prefix, as a plain range its scope routes to that registry, or through the default registry. Before, the plain range was keyed `<name>@<version>`, so one tarball was installed twice and `instanceof` checks and module singletons broke between the two copies. The same name and version served by two registries still get separate entries. When several prefixes declare one registry, its packages are keyed by the lexicographically smallest prefix.
+
+  If a scope you route reaches a registry that also declares a prefix, your next `pnpm install` re-keys those entries, which shows up as a lockfile diff. Commit it. `pnpm install --frozen-lockfile` installs the lockfile as recorded.
+
+- `pnpm install` now resolves a scope's packages again when the scope is routed to another registry in `registries`. Before, the lockfile kept the versions and integrity resolved from the old registry, so the install failed when the new registry did not serve a locked version or served different content. pnpm records in the workspace state which registry each scope routed to, so a fresh clone without that record installs the lockfile as recorded. Changing the default registry resolves nothing again, and `pnpm install --frozen-lockfile` is unchanged.
+
+- When `autoDedupe` is off, a workspace project's dependencies now resolve from its own ranges, like they do with `sharedWorkspaceLockfile: false`. Previously, another project's narrower range could hold them back. For example, `ajv: "*"` now resolves to the latest Ajv even if another project depends on `ajv@^6`. Packages that a project lists in `peerDependencies` still follow the versions other projects use. `pnpm dedupe` and installs with `autoDedupe: true` still pick one version that satisfies every range. Set `autoDedupe: true` if CI runs `pnpm dedupe --check` [#17235](https://github.com/pnpm/pnpm/issues/17235).
+
+- An optional dependency written with a named-registry prefix, such as `work:^1.0.0`, now fails the install when it cannot be resolved but the lockfile already has a matching entry from that registry. Such a dependency was skipped, which removed its entries from the lockfile.
+
+- With `injectWorkspacePackages: true`, a `workspace:` dependency written as a relative path, such as `workspace:../lib-a`, in a workspace package now resolves from that package's directory [#17284](https://github.com/pnpm/pnpm/issues/17284).
+
+- Fixed `pnpm install` failing with `ERR_PNPM_UNSUPPORTED_PROTOCOL` when a workspace package injected through a relative path, such as `workspace:../lib`, has `catalog:` dependencies. Their catalog entries now resolve the way they do for a package injected by name [#17280](https://github.com/pnpm/pnpm/issues/17280).
+
+- `pnpm dedupe` now refreshes cached registry metadata while re-resolving locked versions [#17208](https://github.com/pnpm/pnpm/issues/17208).
+
+- `pnpm dedupe --check` no longer fails when the only difference is a `deprecated` notice that the registry added or removed after the lockfile was written [#17198](https://github.com/pnpm/pnpm/issues/17198).
+
+- Installs delegated to a pnpr server now resolve every prefix declared for a registry URL. A dependency or lockfile entry that used the second of two prefixes for the same registry, such as `zeta:` next to `work:` in `namedRegistries`, failed on the server [pnpm/tasks#204](https://github.com/pnpm/tasks/issues/204).
+
+- Registry revisions are now addressed at `<registry>/<name>@<version>+r<revision>` [pnpm/tasks#208](https://github.com/pnpm/tasks/issues/208).
+
+#### Adding packages and global packages
+
+- `pnpm add <pkg>@<tag>` and `pnpm add <pkg>@<range>` now install the version the tag or range resolves to, even when the saved range allows a newer one [#17234](https://github.com/pnpm/pnpm/issues/17234).
+
+- `pnpm add <pkg>` without a version now installs the version under the dist-tag set by the `tag` setting. An `npm:` alias or a `jsr:` dependency without a version resolves that tag too. The setting is read from `pnpm-workspace.yaml`, the global config, `PNPM_CONFIG_TAG`, and `--config.tag`, and defaults to `latest`.
+
+- `pnpm add` now accepts the lowercase short options `-p`, `-d`, `-o`, and `-e` as aliases of `--save-prod`, `--save-dev`, `--save-optional`, and `--save-exact`.
+
+- `pnpm -D install <pkg>` now saves the package to devDependencies. An `add` option such as `-D` or `-E` written before `install <pkg>` was rejected as an unexpected argument.
+
+- `pnpm add -T` now reports that the short option is ambiguous and points to `--save-types` and `--tilde`.
+
+- Global packages installed with `pnpm add -g` are now linked from the global virtual store, so global packages that share dependencies share one copy. Set `virtualStoreType: project` to give each global install its own virtual store.
+
+- `pnpm add -g` and the other `--global` commands now fail with `ERR_PNPM_CONFIG_CONFLICT_VIRTUAL_STORE_DIR_WITH_GLOBAL` when `--virtual-store-dir` is passed. A custom `--hoist-pattern` fails with `ERR_PNPM_CONFIG_CONFLICT_HOIST_PATTERN_WITH_GLOBAL`. Passing `--link-workspace-packages`, `--shared-workspace-lockfile`, or `--config.lockfile-dir` with `--global` also fails, with the matching `ERR_PNPM_CONFIG_CONFLICT_*_WITH_GLOBAL` code.
+
+#### Registries, proxies, and login
+
+- pnpm now reads the `strictSsl` and `localAddress` settings from `pnpm-workspace.yaml`, the global `config.yaml`, `PNPM_CONFIG_*` environment variables, and `--config.*` options. This includes `pnpm self-update` and the download of the pnpm version pinned in `packageManager`. Before, pnpm read them only from `.npmrc` as `strict-ssl` and `local-address` and ignored the other sources [pnpm/tasks#201](https://github.com/pnpm/tasks/issues/201).
+
+- When Corepack runs pnpm and the native binary has to be downloaded, the download now uses the proxy from pnpm's config. That proxy comes from `PNPM_CONFIG_HTTPS_PROXY` and the matching variables, the global `config.yaml`, and the user `.npmrc`. Previously, the download read the proxy only from `HTTPS_PROXY`, `HTTP_PROXY`, and `NO_PROXY` [pnpm/tasks#215](https://github.com/pnpm/tasks/issues/215).
+
+- When the `pnpm` package downloads its native binary on first run, as it does under Corepack, it now trusts the CA certificates from the `ca`, `ca[]`, and `cafile` settings of `.npmrc`, including the ones scoped to the registry. A registry behind a private CA failed with `fetch failed` before, unless `NODE_EXTRA_CA_CERTS` named the CA. A project `.npmrc` is used only while the download is checked against npm's signature. Node.js versions that cannot add CA certificates after startup still need `NODE_EXTRA_CA_CERTS`.
+
+- `pnpm login` saves the token in `<pnpm config>/auth.ini` again. Since v12.1.0, an unscoped login had made its registry the default for every project that did not name a registry. A login now also removes the token an earlier login saved for that registry or scope under `_auth` in the global `config.yaml`. `pnpm login --scope` still routes the scope through the global `registries` setting.
+
+- pnpm no longer warns that a `registries` entry routed through the `@` scope matches no configured registry. pnpm applied such an entry and its options such as `serverType` while reporting it as ignored [pnpm/tasks#184](https://github.com/pnpm/tasks/issues/184).
+
+#### Running scripts and other commands
+
+- `pnpm ci --lockfile` and `pnpm ci --config.lockfile=true` no longer delete `pnpm-lock.yaml`. `pnpm ci` now always keeps the lockfile and runs a frozen install from it.
+
+- `pnpm deploy --legacy` now checks the workspace lockfile against `minimumReleaseAge` and the other resolution policies, as `pnpm install` does, and fails with `ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION` when a locked version is too new. It used to deploy an older version that is not in the lockfile without a warning [#17209](https://github.com/pnpm/pnpm/issues/17209).
+
+- `pnpm deploy` now keeps a deployed symlink to a directory inside the project even if the directory is not among the deployed files, such as a link into `node_modules` [#17288](https://github.com/pnpm/pnpm/issues/17288).
+
+- `pnpm pack` and `pnpm publish` now keep `pnpm.config` in the published `package.json`. They also always include the file `pnpm.config` points to in the tarball [#17210](https://github.com/pnpm/pnpm/issues/17210).
+
+- `pnpm -r publish --batch` now sends `PUT /-/pnpr/v0/publish`, the batch publish endpoint that pnpr serves.
+
+- `pnpm audit --ignore` and `pnpm audit --ignore-unfixable` now exit with a non-zero code when vulnerabilities at or above the audit level remain after ignoring. Before, these commands always exited with code 0.
+
+- `pnpm audit --fix` and `pnpm audit --interactive` now fail with `ERR_PNPM_AUDIT_FIX_WITH_IGNORE` when combined with `--ignore` or `--ignore-unfixable`. Before, the fix ran and the ignore flags had no effect.
+
+- `pnpm -r run <script>` now honors the `requiredScripts` setting from `pnpm-workspace.yaml`. If the script is listed there and a selected project does not define it, the run fails with `ERR_PNPM_RECURSIVE_RUN_NO_SCRIPT` and names the projects that lack it.
+
+- `pnpm run` and `pnpm exec` no longer report the dependencies as out of date after a lockfile change when `dedupePeers` is `true` [#17322](https://github.com/pnpm/pnpm/issues/17322).
+
+- On macOS, killing pnpm while it runs scripts in several projects at once now ends every one of those scripts. Before, a script could keep running after pnpm died.
+
+- `pnpm run`, `pnpm exec`, and `pnpm dlx` no longer dump a core file for `pnpm` itself when a command they started dies from a signal [#17204](https://github.com/pnpm/pnpm/issues/17204).
+
+- The `runtime` setting is now read. Setting `runtime: false` in `pnpm-workspace.yaml`, `pnpm_config_runtime=false`, or `--config.runtime=false` stops `pnpm install`, `pnpm add`, `pnpm dedupe`, and the other installing commands from installing the runtimes in `devEngines.runtime` and `engines.runtime`. `pnpm dedupe` now also accepts `--no-runtime`.
+
+- Directory selectors with `legacyDirFiltering: true` now include the project in the named directory along with its descendants. Excluding a directory also excludes that project [pnpm/tasks#196](https://github.com/pnpm/tasks/issues/196).
+
+- `pnpm help --all` and `pnpm help -a` now print the full list of commands. They used to fail with an "unrecognized subcommand" error.
+
+- Reading the file-creation mask on Linux no longer sets it. pnpm had to replace the mask to learn what it was, and a file another thread created in the window between the two calls was created unmasked.
+
+- pnpm now passes an interrupt on to the handler it replaced, with the arguments that handler expects. A handler that asked for the signal's details was called without them. Only a program that embeds pnpm and installs its own `SIGINT`, `SIGTERM` or `SIGHUP` handler was affected.
+
+#### Store
+
+- `pnpm store prune` now keeps the packages that a project still uses when pnpm copied or cloned them into `node_modules`. These include patched packages, built packages, and every package installed with `packageImportMethod: copy`. Before, the prune removed them, and the next install downloaded them again [#7192](https://github.com/pnpm/pnpm/issues/7192).
+
+- `pnpm store prune` now keeps the packages of a project when the store path reaches its directory through a symlink. Previously, prune dropped such a project from its list and removed the packages only that project used from the global virtual store.
+
+- `pnpm store prune` now removes the package metadata cache, the `metadata*` directories in the cache directory. This clears the outdated integrity checksums that cause `ERR_PNPM_TARBALL_INTEGRITY` when a registry republishes a version.
+
+#### Speed
+
+- `pnpm install` resolves dependencies faster in large workspaces on Linux, macOS, and Windows on x64 and arm64.
+
+- Sped up cold installs and `pnpm fetch` on macOS. pnpm now links downloaded packages into the virtual store on a separate thread, so a slow link pass no longer pauses the downloads that are still in flight [#17271](https://github.com/pnpm/pnpm/issues/17271).
+
+- Sped up installs that add new projects to a workspace with a peer-heavy lockfile. pnpm now reads the lockfile's locked peer versions once for all new projects [#17311](https://github.com/pnpm/pnpm/issues/17311).
+
+- Warm installs no longer read the `package.json` of every git-hosted dependency. pnpm now stores the manifest of a git-hosted package in the store index when it fetches the package.
+
+- `pnpm update --depth <n>` with a large `n`, such as the `--depth=9999` that `update-browserslist-db` runs, now finishes as fast as `--depth Infinity`. It used memory and stack in proportion to `n` on lockfiles with dependency cycles, and could run out of memory or crash [#17329](https://github.com/pnpm/pnpm/issues/17329).
+
+#### Output and warnings
+
+- Output that fills the terminal, such as `pnpm run --stream` script output, is now written once. Before, every new line also rewrote all the lines already on screen [#17387](https://github.com/pnpm/pnpm/issues/17387).
+
+- pnpm now warns when a pnpmfile defines the `importPackage` hook. pnpm does not run this hook. Use the `packageImportMethod` setting to choose how packages are written to `node_modules`.
+
+- `pnpm` now warns when a project's `pnpm-workspace.yaml` sets `ci`, `globalShims`, or `tools`, and names where to set them instead. These settings were already ignored there without a warning. `pnpm config set` also refuses to write them to a project's `pnpm-workspace.yaml`.
+
+- pnpm no longer documents the `scriptsPrependNodePath` setting, which has no effect. A `pnpm-workspace.yaml` that sets it still loads.
+
 ## 12.15.0
 
 This release lets `pnpm-workspace.yaml` delegate settings to other files and config dependencies with `include`, adds `lockfile.integrityTarget: tar` and tar-registry support, accepts zstd-compressed registry responses, and honors `SOURCE_DATE_EPOCH` in `pnpm deploy` and `pnpm install`. It also rejects registry metadata that names a different package than the one requested and speeds up workspace installs and macOS file linking.

package/README.md

@@ -24,7 +24,7 @@ Fast, disk space efficient package manager:
 
 To quote the [Rush](https://rushjs.io/) team:
 
-> Microsoft uses pnpm in Rush repos with hundreds of projects and hundreds of PRs per day, and we’ve found it to be very fast and reliable.
+> Microsoft uses pnpm in Rush repos with hundreds of projects and hundreds of PRs per day, and we've found it to be very fast and reliable.
 
 [![npm version](https://img.shields.io/npm/v/pnpm.svg?label=latest)](https://github.com/pnpm/pnpm/releases/latest)
 [![OpenCollective](https://opencollective.com/pnpm/backers/badge.svg)](https://opencollective.com/pnpm)
@@ -239,7 +239,7 @@ With pnpm, lodash will be stored in a content-addressable storage, so:
 1. All the files are saved in a single place on the disk. When packages are installed, their files are linked
   from that single place consuming no additional disk space. Linking is performed using either hard-links or reflinks (copy-on-write).
 
-As a result, you save gigabytes of space on your disk and you have a lot faster installations!
+As a result, you save gigabytes of space on your disk and you have a lot faster installations.
 If you'd like more details about the unique `node_modules` structure that pnpm creates and
 why it works fine with the Node.js ecosystem, read this small article: [Flat node_modules is not the only way](https://pnpm.io/blog/2020/05/27/flat-node-modules-is-not-the-only-way).
 
@@ -251,7 +251,7 @@ For installation options [visit our website](https://pnpm.io/installation).
 
 ## Usage
 
-Just use pnpm in place of npm/Yarn. E.g., install dependencies via:
+Use pnpm in place of npm/Yarn. E.g., install dependencies via:
 
 ```
 pnpm install
@@ -261,7 +261,7 @@ For more advanced usage, read [pnpm CLI](https://pnpm.io/pnpm-cli) on our websit
 
 ## Benchmark
 
-pnpm is up to 2x faster than npm and Yarn classic. See all benchmarks [here](https://r.pnpm.io/benchmarks).
+pnpm is up to 2x faster than npm and Yarn classic. See [all benchmarks](https://r.pnpm.io/benchmarks).
 
 Benchmarks on an app with lots of dependencies:
 

package/bin/pnpm.mjs

@@ -15,15 +15,13 @@
 // payload it ships node-gyp in. The placeholder's installs usually do carry
 // that package, and the binary is taken from there.
 //
-// The download itself is `get-pnpm`, the package behind https://get.pnpm.io,
+// The download itself is `get-pnpm`, the installer in ../../get-pnpm,
 // which already knows how to verify one; it travels in that same `dist/`
-// payload. What is left here is what it does not know: where to download from,
-// what credentials to use, and whose signature to trust.
-import { Buffer } from 'node:buffer'
+// payload, and reads the registry, credentials, and signing keys from pnpm's
+// and Corepack's config.
 import { spawnSync } from 'node:child_process'
 import console from 'node:console'
 import fs from 'node:fs'
-import net from 'node:net'
 import os from 'node:os'
 import path from 'node:path'
 import process from 'node:process'
@@ -37,7 +35,6 @@ const DOWNLOADED_BINARY = path.join(
   process.platform === 'win32' ? 'pnpm-native.exe' : 'pnpm-native'
 )
 const GET_PNPM = new URL('../dist/node_modules/get-pnpm/lib/index.js', import.meta.url)
-const DEFAULT_REGISTRY = 'https://registry.npmjs.org'
 
 if ('webcontainer' in process.versions) {
   fail('The pnpm package runs a native binary, which WebContainers cannot execute. Install @pnpm/wasm instead.')
@@ -70,242 +67,23 @@ async function nativeBinary () {
     return DOWNLOADED_BINARY
   }
 
-  if (process.env.COREPACK_ENABLE_NETWORK === '0') {
-    fail('Network access is disabled by the environment, so the pnpm binary cannot be downloaded.')
-  }
-
   const { version } = readWrapperManifest()
-  console.error(`Downloading the pnpm ${version} binary for ${process.platform}-${process.arch}...`)
-  const { downloadPnpmExecutable } = await import(GET_PNPM).catch((err) => {
+  const { corepackDownloadOptions, downloadPnpmExecutable } = await import(GET_PNPM).catch((err) => {
     fail(`This copy of the pnpm package is missing the downloader it needs: ${err.message}`)
   })
-  const signature = signaturePolicy()
+  let options
   try {
-    await downloadPnpmExecutable({
-      version,
-      destPath: DOWNLOADED_BINARY,
-      ...registryAccess({ readProjectNpmrc: signature.verifySignature !== false }),
-      ...signature,
-    })
+    options = corepackDownloadOptions()
   } catch (err) {
-    fail(`Could not download the pnpm ${version} binary: ${err.message}`)
-  }
-  return DOWNLOADED_BINARY
-}
-
-/**
- * The registry to download from, and the headers to send it. Corepack's
- * `COREPACK_NPM_REGISTRY` wins. Otherwise npm's sources decide, highest first:
- * the environment, the project `.npmrc`, the user `.npmrc`.
- *
- * The project `.npmrc` is read only with `readProjectNpmrc`, which the caller
- * passes while the download is checked against npm's signature. The signature
- * pins the bytes, so a repository picks only where they come from. Unchecked,
- * it would pick the binary itself, which is kept next to this wrapper and run
- * in every later project (GHSA-j2hc-m6cf-6jm8). `get-pnpm` keeps the headers on
- * the registry's origin, so a download host it names never receives them.
- */
-function registryAccess ({ readProjectNpmrc }) {
-  const corepackRegistry = process.env.COREPACK_NPM_REGISTRY
-  if (corepackRegistry) {
-    return { registry: corepackRegistry, headers: corepackHeaders() }
+    fail(err.message)
   }
-  const npmrc = readUserNpmrc()
-  if (readProjectNpmrc) {
-    Object.assign(npmrc, readNpmrc(path.join(projectDir(), '.npmrc'), projectEntry))
-  }
-  const registry = npmrc['@pnpm:registry'] || settingFromEnv('registry') || npmrc.registry
-  if (!registry) {
-    return { registry: DEFAULT_REGISTRY, headers: corepackHeaders() }
-  }
-  return { registry, headers: npmrcHeaders(npmrc, registry) }
-}
-
-/** Credentials for Corepack's registry, read the way Corepack reads its own. */
-function corepackHeaders () {
-  const { COREPACK_NPM_TOKEN, COREPACK_NPM_USERNAME, COREPACK_NPM_PASSWORD } = process.env
-  if (COREPACK_NPM_TOKEN) {
-    return { authorization: `Bearer ${COREPACK_NPM_TOKEN}` }
-  }
-  if (COREPACK_NPM_USERNAME && COREPACK_NPM_PASSWORD) {
-    return { authorization: `Basic ${base64(`${COREPACK_NPM_USERNAME}:${COREPACK_NPM_PASSWORD}`)}` }
-  }
-  return undefined
-}
-
-function settingFromEnv (key) {
-  const upper = key.toUpperCase()
-  const { env } = process
-  return env[`pnpm_config_${key}`] || env[`PNPM_CONFIG_${upper}`] ||
-    env[`npm_config_${key}`] || env[`NPM_CONFIG_${upper}`] || undefined
-}
-
-/** The user `.npmrc`, with `${VAR}` placeholders expanded. */
-function readUserNpmrc () {
-  return readNpmrc(
-    settingFromEnv('userconfig') || path.join(os.homedir(), '.npmrc'),
-    (key, value) => [expandEnv(key), expandEnv(value)]
-  )
-}
-
-/**
- * A project `.npmrc` entry, which is not expanded. One with a `${VAR}`
- * placeholder in a registry setting or a credential is dropped, as pnpm drops
- * it: a repository must not route the user's environment to a registry.
- */
-function projectEntry (key, value, file) {
-  if (!key.includes('${') && !value.includes('${')) {
-    return [key, value]
-  }
-  if (key.startsWith('//') || key === 'registry' || key.endsWith(':registry')) {
-    console.error(`Ignored ${key} from ${file}: a project .npmrc cannot use environment variables in registry settings or credentials.`)
-  }
-  return undefined
-}
-
-/** Where pnpm reads the project `.npmrc`: the workspace root, or else the current directory. */
-function projectDir () {
-  const cwd = process.cwd()
-  for (let dir = cwd; ; dir = path.dirname(dir)) {
-    if (fs.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
-      return dir
-    }
-    if (path.dirname(dir) === dir) {
-      return cwd
-    }
-  }
-}
-
-/**
- * The top-level settings of the `.npmrc` at `file`, each passed through
- * `parseEntry`, which returns the `[key, value]` to keep or `undefined`.
- */
-function readNpmrc (file, parseEntry) {
-  const settings = Object.create(null)
-  let text
-  try {
-    text = fs.readFileSync(file, 'utf8')
-  } catch (err) {
-    if (err.code !== 'ENOENT' && err.code !== 'EISDIR') {
-      console.error(`Could not read ${file}, so its settings are not used: ${err.message}`)
-    }
-    return settings
-  }
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    // Settings under a `[section]` are not top-level ones.
-    if (line.startsWith('[')) {
-      break
-    }
-    const separator = line.indexOf('=')
-    if (separator === -1 || line.startsWith(';') || line.startsWith('#')) {
-      continue
-    }
-    const entry = parseEntry(line.slice(0, separator).trim(), unquote(line.slice(separator + 1).trim()), file)
-    if (entry != null) {
-      settings[entry[0]] = entry[1]
-    }
-  }
-  return settings
-}
-
-function unquote (value) {
-  const quoted = value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.at(-1) === value[0]
-  return quoted ? value.slice(1, -1) : value
-}
-
-function expandEnv (value) {
-  return value.replace(/\$\{([^${}]+)\}/g, (_, name) => process.env[name] ?? '')
-}
-
-/**
- * The credentials the `.npmrc` holds for `registry`, looked up as pnpm looks
- * them up for an `@pnpm` package: the `@pnpm` scope's own credentials first,
- * then the registry-wide ones. Each is the longest `//host[:port]/path/`
- * prefix of the registry URL that has any, then the same without the port.
- * They are sent only over HTTPS or to the local machine.
- */
-function npmrcHeaders (npmrc, registry) {
-  const url = new URL(registry.endsWith('/') ? registry : `${registry}/`)
-  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && isLoopback(url.hostname))) {
-    return undefined
-  }
-  const prefixes = []
-  for (const host of new Set([url.host, url.hostname])) {
-    for (let pathname = url.pathname; ; pathname = pathname.slice(0, pathname.lastIndexOf('/', pathname.length - 2) + 1)) {
-      prefixes.push(`//${host}${pathname}`)
-      if (pathname === '/') {
-        break
-      }
-    }
-  }
-  for (const scope of [':@pnpm', '']) {
-    for (const prefix of prefixes) {
-      const authorization = npmrcAuthorization(npmrc, `${prefix}${scope}`)
-      if (authorization != null) {
-        return { authorization }
-      }
-    }
-  }
-  return undefined
-}
-
-function isLoopback (hostname) {
-  return hostname === 'localhost' || hostname === '[::1]' ||
-    (net.isIPv4(hostname) && hostname.startsWith('127.'))
-}
-
-function npmrcAuthorization (npmrc, prefix) {
-  const token = npmrc[`${prefix}:_authToken`]
-  if (token) {
-    return `Bearer ${token}`
-  }
-  const auth = npmrc[`${prefix}:_auth`]
-  if (auth) {
-    return `Basic ${auth}`
-  }
-  const username = npmrc[`${prefix}:username`]
-  const password = npmrc[`${prefix}:_password`]
-  if (username && password) {
-    return `Basic ${base64(`${username}:${Buffer.from(password, 'base64').toString('utf8')}`)}`
-  }
-  return undefined
-}
-
-function base64 (text) {
-  return Buffer.from(text, 'utf8').toString('base64')
-}
-
-/**
- * Whose signature over the download to trust, following `COREPACK_INTEGRITY_KEYS`
- * exactly as Corepack does: npm's own keys when it is unset, the keys it names
- * when it holds a key set, and no signature check at all when it is `0` or
- * empty — which is the state a registry that re-publishes packages, and
- * therefore carries no npm signatures, already has to be in for Corepack to
- * have installed this wrapper from it.
- */
-function signaturePolicy () {
-  const configured = process.env.COREPACK_INTEGRITY_KEYS
-  if (configured == null) {
-    return {}
-  }
-  if (configured === '' || configured === '0') {
-    return { verifySignature: false }
-  }
-  let keys
+  console.error(`Downloading the pnpm ${version} binary for ${process.platform}-${process.arch}...`)
   try {
-    keys = JSON.parse(configured).npm
+    await downloadPnpmExecutable({ version, destPath: DOWNLOADED_BINARY, ...options })
   } catch (err) {
-    fail(`COREPACK_INTEGRITY_KEYS is not readable as JSON: ${err.message}`)
-  }
-  // An absent or malformed `npm` entry would otherwise be passed on as no keys
-  // at all, which falls back to npm's own — the opposite of what setting the
-  // variable asked for. An empty set is left alone: it names no key to trust,
-  // and Corepack reads it the same way, so every download is refused.
-  if (!Array.isArray(keys)) {
-    fail('COREPACK_INTEGRITY_KEYS holds no "npm" key set to verify the pnpm binary against.')
+    fail(`Could not download the pnpm ${version} binary: ${err.message}`)
   }
-  return { keys }
+  return DOWNLOADED_BINARY
 }
 
 function fail (message) {