@pnpm/exe 12.8.1 → 12.9.0

package/install.js

@@ -1,24 +1,7 @@
 #!/usr/bin/env node
-// Preinstall for the pnpm v12 wrapper (shared verbatim by `pnpm` and
-// `@pnpm/exe`): replace the shebang-less placeholder bins with the host's native
-// binary so `pnpm` runs directly, no Node startup per call. The placeholder must
-// stay shebang-less because pnpm 11 records its interpreter before installing
-// the native binary at the same path. npm's global Windows shims still target
-// the extensionless path after the `bin` rewrite, so postinstall asks npm to
-// regenerate them against `pnpm.exe`. A global install uses `npm rebuild
-// --global`. A project install passes the project prefix, because the
-// script's working directory is the installed package. Any other install,
-// such as `npm exec`, keeps its shims. When lifecycle scripts are blocked
-// (`--ignore-scripts`, pnpm/Bun default), the placeholder remains and runs pnpm
-// through Node.js wherever a shell reaches it (see the `pnpm` file).
-//
-// `pn`/`pnpx`/`pnx` are committed `#!/bin/sh` scripts on Unix (so only `pnpm` is
-// relinked); on Windows the native binary is hardlinked onto each and
-// self-detects its launch name to inject `dlx` (see `argv_with_alias_subcommand`
-// in the cli crate).
-//
-// Corepack runs no lifecycle scripts, so it never gets here; it enters through
-// `bin/pnpm.mjs` instead.
+// Native installs replace the Node entry points with the host binary. npm's
+// Windows shims must then be regenerated against pnpm.exe; Corepack and
+// installations that block lifecycle scripts keep the Node entry points.
 import console from 'node:console'
 import { spawnSync } from 'node:child_process'
 import fs from 'node:fs'
@@ -49,6 +32,11 @@ function setup () {
     return
   }
 
+  if ('webcontainer' in process.versions) {
+    validateWebContainerRuntime()
+    return
+  }
+
   const candidates = getBinCandidates()
   if (candidates.length === 0) {
     fail(`pnpm does not ship a prebuilt binary for ${hostTarget()}.`)
@@ -75,7 +63,16 @@ function setup () {
     }
     rewriteBin(newBin)
   } else {
-    placeBinary(nativeBinary, path.join(wrapperDir, 'pnpm'), 0o755)
+    for (const name of BIN_NAMES) {
+      placeBinary(nativeBinary, path.join(wrapperDir, name), 0o755)
+    }
+  }
+}
+
+function validateWebContainerRuntime () {
+  const runtime = path.join(wrapperDir, 'dist', 'wasm', 'pnpm.wasm')
+  if (!fs.statSync(runtime, { throwIfNoEntry: false })?.isFile()) {
+    fail('The pnpm package is missing its bundled WebContainer runtime. Reinstall pnpm.')
   }
 }
 

package/package.json

@@ -9,7 +9,7 @@
       "./dist/node_modules/node-gyp/gyp/gyp"
     ]
   },
-  "version": "12.8.1",
+  "version": "12.9.0",
   "description": "Fast, disk space efficient package manager",
   "keywords": [
     "pnpm",
@@ -17,7 +17,7 @@
     "rust"
   ],
   "license": "MIT",
-  "homepage": "https://github.com/pnpm/pnpm/tree/main/pnpm",
+  "homepage": "https://pnpm.io",
   "bugs": "https://github.com/pnpm/pnpm/issues",
   "repository": {
     "type": "git",
@@ -46,20 +46,20 @@
     "THIRD-PARTY-NOTICES.md"
   ],
   "optionalDependencies": {
-    "@pnpm/exe.win32-x64": "12.8.1",
-    "@pnpm/exe.win32-arm64": "12.8.1",
-    "@pnpm/exe.darwin-x64": "12.8.1",
-    "@pnpm/exe.darwin-arm64": "12.8.1",
-    "@pnpm/exe.linux-x64": "12.8.1",
-    "@pnpm/exe.linux-arm64": "12.8.1",
-    "@pnpm/exe.linux-riscv64": "12.8.1",
-    "@pnpm/exe.linux-ppc64": "12.8.1",
-    "@pnpm/exe.linux-s390x": "12.8.1",
-    "@pnpm/exe.linux-x64-musl": "12.8.1",
-    "@pnpm/exe.linux-arm64-musl": "12.8.1",
-    "@pnpm/exe.freebsd-x64": "12.8.1",
-    "@pnpm/exe.android-arm64": "12.8.1",
-    "@pnpm/exe.android-x64": "12.8.1"
+    "@pnpm/exe.win32-x64": "12.9.0",
+    "@pnpm/exe.win32-arm64": "12.9.0",
+    "@pnpm/exe.darwin-x64": "12.9.0",
+    "@pnpm/exe.darwin-arm64": "12.9.0",
+    "@pnpm/exe.linux-x64": "12.9.0",
+    "@pnpm/exe.linux-arm64": "12.9.0",
+    "@pnpm/exe.linux-riscv64": "12.9.0",
+    "@pnpm/exe.linux-ppc64": "12.9.0",
+    "@pnpm/exe.linux-s390x": "12.9.0",
+    "@pnpm/exe.linux-x64-musl": "12.9.0",
+    "@pnpm/exe.linux-arm64-musl": "12.9.0",
+    "@pnpm/exe.freebsd-x64": "12.9.0",
+    "@pnpm/exe.android-arm64": "12.9.0",
+    "@pnpm/exe.android-x64": "12.9.0"
   },
   "scripts": {
     "preinstall": "node install.js",

package/pn

@@ -1,70 +1,2 @@
-#!/bin/sh
-# `pn` is `pnpm`. The pnpm it hands over to is the one installed alongside it,
-# found relative to this file: a `PATH` lookup would run whatever other pnpm
-# comes first there, and would find nothing at all when the directory holding
-# these bins is not on `PATH`.
-#
-# $0 is whatever shim or symlink `pn` was launched through, so walk to the file
-# itself first. The hop cap matches the kernel's ELOOP limit, so a cycle cannot
-# hang the script. Directories come from `${self%/*}` and `readlink` runs through
-# `command -p`, so the caller's `PATH` decides nothing here.
-#
-# Where no default path is compiled in, as on Nix, `command -p` searches PATH
-# instead, so the helpers run with node_modules and relative entries dropped from
-# PATH.
-caller_path_set=${PATH+set}
-caller_path=${PATH-}
-helper_path=
-rest=$caller_path:
-while [ -n "$rest" ]; do
-  dir=${rest%%:*}
-  rest=${rest#*:}
-  case "$dir" in
-    */node_modules/*|*/node_modules) ;;
-    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
-  esac
-done
-# An empty PATH searches the current directory.
-PATH=${helper_path:-/}
-self=$0
-# MSYS and Cygwin can launch this with a native Windows path, which has no slash
-# for `${self%/*}` to strip. Only a drive letter or a UNC prefix marks one; a
-# backslash anywhere else is an ordinary character in a Unix file name, so the
-# path is left alone. The separators are swapped in the shell rather than through
-# `echo`, which mangles a `\t` or `\b` in a path under dash.
-case $self in
-  [A-Za-z]:\\*|\\\\*)
-    while :; do
-      case $self in
-        *\\*) self=${self%%\\*}/${self#*\\} ;;
-        *) break ;;
-      esac
-    done
-    ;;
-esac
-# `${self%/*}` needs a slash to strip. A bare name came from a `PATH` lookup and
-# stands for a file in the current directory.
-case $self in
-  */*) ;;
-  *) self=./$self ;;
-esac
-hops=0
-while [ -L "$self" ] && [ "$hops" -lt 40 ]; do
-  hops=$((hops + 1))
-  link=$(command -p readlink "$self")
-  case $link in
-    /*) self=$link ;;
-    *) self=${self%/*}/$link ;;
-  esac
-done
-if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
-# The walk has to end at a regular file. Running out of hops leaves $self a
-# symlink; a chain that changed under us can leave it dangling or a directory, and
-# a failed readlink leaves a trailing slash. Each case would take `pnpm` from the
-# wrong directory — the substitution this script exists to prevent.
-if [ -L "$self" ] || [ ! -f "$self" ]; then
-  echo "pn: could not resolve $0 to a regular file within 40 symlink hops." >&2
-  exit 1
-fi
-
-exec "${self%/*}/pnpm" "$@"
+#!/usr/bin/env node
+import './bin/pnpm.mjs'

package/pnpm

@@ -1,90 +1,2 @@
-# pnpm's native binary replaces this file during installation (see
-# ./install.js). Until then this hands over to ./bin/pnpm.mjs, which finds the
-# installed binary or downloads one and spawns it.
-#
-# Shebang-less on purpose, and therefore an `sh` script: a bin shim generated
-# from a shebang records that interpreter, and pnpm 11 generates the shim before
-# it puts the native binary at this path.
-#
-# Something has to retry this file under a shell, because the kernel answers
-# ENOEXEC for it. A bin shim and a shell both do, and so does glibc's `execvp`.
-# Apple's libc does not, so on macOS a program that spawns this path itself gets
-# ENOEXEC; Windows has neither and cannot reach it at all.
-if ! command -v node > /dev/null 2>&1; then
-  echo "pnpm's native binary was not installed, and there is no Node.js to run pnpm without it." >&2
-  echo "Reinstall pnpm with build scripts enabled (allow-list pnpm's build under pnpm or Bun, or drop --ignore-scripts)." >&2
-  exit 1
-fi
-
-if [ -t 2 ]; then
-  echo "pnpm is running through Node.js because the script that installs its native binary was skipped." >&2
-  echo "Reinstall pnpm with its build scripts allowed to run the binary directly." >&2
-fi
-
-# $0 is whatever shim or symlink pnpm was launched through; ./bin/pnpm.mjs is
-# found relative to this file. The hop cap matches the kernel's ELOOP limit, so
-# a cycle cannot hang the script.
-#
-# `readlink` runs through `command -p`, which searches the system default path,
-# and directories come from `${self%/*}`, which runs nothing at all. The caller's
-# PATH therefore decides only which `node` runs, which is what it is for.
-#
-# Where no default path is compiled in, as on Nix, `command -p` searches PATH
-# instead, so the helpers run with node_modules and relative entries dropped from
-# PATH.
-caller_path_set=${PATH+set}
-caller_path=${PATH-}
-helper_path=
-rest=$caller_path:
-while [ -n "$rest" ]; do
-  dir=${rest%%:*}
-  rest=${rest#*:}
-  case "$dir" in
-    */node_modules/*|*/node_modules) ;;
-    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
-  esac
-done
-# An empty PATH searches the current directory.
-PATH=${helper_path:-/}
-self=$0
-# MSYS and Cygwin can launch this with a native Windows path, which has no slash
-# for `${self%/*}` to strip. Only a drive letter or a UNC prefix marks one; a
-# backslash anywhere else is an ordinary character in a Unix file name, so the
-# path is left alone. The separators are swapped in the shell rather than through
-# `echo`, which mangles a `\t` or `\b` in a path under dash.
-case $self in
-  [A-Za-z]:\\*|\\\\*)
-    while :; do
-      case $self in
-        *\\*) self=${self%%\\*}/${self#*\\} ;;
-        *) break ;;
-      esac
-    done
-    ;;
-esac
-# `${self%/*}` needs a slash to strip. A bare name came from a PATH lookup and
-# stands for a file in the current directory.
-case $self in
-  */*) ;;
-  *) self=./$self ;;
-esac
-hops=0
-while [ -L "$self" ] && [ "$hops" -lt 40 ]; do
-  hops=$((hops + 1))
-  link=$(command -p readlink "$self")
-  case $link in
-    /*) self=$link ;;
-    *) self=${self%/*}/$link ;;
-  esac
-done
-if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
-# The walk has to end at a regular file. Running out of hops leaves $self a
-# symlink; a chain that changed under us can leave it dangling or a directory, and
-# a failed readlink leaves a trailing slash. Each case would take `bin/pnpm.mjs`
-# from the wrong directory.
-if [ -L "$self" ] || [ ! -f "$self" ]; then
-  echo "pnpm: could not resolve $0 to a regular file within 40 symlink hops." >&2
-  exit 1
-fi
-
-exec node "${self%/*}/bin/pnpm.mjs" "$@"
+#!/usr/bin/env node
+import './bin/pnpm.mjs'

package/pnpx

@@ -1,70 +1,2 @@
-#!/bin/sh
-# `pnpx` is `pnpm dlx`. The pnpm it hands over to is the one installed alongside
-# it, found relative to this file: a `PATH` lookup would run whatever other pnpm
-# comes first there, and would find nothing at all when the directory holding
-# these bins is not on `PATH`.
-#
-# $0 is whatever shim or symlink `pnpx` was launched through, so walk to the file
-# itself first. The hop cap matches the kernel's ELOOP limit, so a cycle cannot
-# hang the script. Directories come from `${self%/*}` and `readlink` runs through
-# `command -p`, so the caller's `PATH` decides nothing here.
-#
-# Where no default path is compiled in, as on Nix, `command -p` searches PATH
-# instead, so the helpers run with node_modules and relative entries dropped from
-# PATH.
-caller_path_set=${PATH+set}
-caller_path=${PATH-}
-helper_path=
-rest=$caller_path:
-while [ -n "$rest" ]; do
-  dir=${rest%%:*}
-  rest=${rest#*:}
-  case "$dir" in
-    */node_modules/*|*/node_modules) ;;
-    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
-  esac
-done
-# An empty PATH searches the current directory.
-PATH=${helper_path:-/}
-self=$0
-# MSYS and Cygwin can launch this with a native Windows path, which has no slash
-# for `${self%/*}` to strip. Only a drive letter or a UNC prefix marks one; a
-# backslash anywhere else is an ordinary character in a Unix file name, so the
-# path is left alone. The separators are swapped in the shell rather than through
-# `echo`, which mangles a `\t` or `\b` in a path under dash.
-case $self in
-  [A-Za-z]:\\*|\\\\*)
-    while :; do
-      case $self in
-        *\\*) self=${self%%\\*}/${self#*\\} ;;
-        *) break ;;
-      esac
-    done
-    ;;
-esac
-# `${self%/*}` needs a slash to strip. A bare name came from a `PATH` lookup and
-# stands for a file in the current directory.
-case $self in
-  */*) ;;
-  *) self=./$self ;;
-esac
-hops=0
-while [ -L "$self" ] && [ "$hops" -lt 40 ]; do
-  hops=$((hops + 1))
-  link=$(command -p readlink "$self")
-  case $link in
-    /*) self=$link ;;
-    *) self=${self%/*}/$link ;;
-  esac
-done
-if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
-# The walk has to end at a regular file. Running out of hops leaves $self a
-# symlink; a chain that changed under us can leave it dangling or a directory, and
-# a failed readlink leaves a trailing slash. Each case would take `pnpm` from the
-# wrong directory — the substitution this script exists to prevent.
-if [ -L "$self" ] || [ ! -f "$self" ]; then
-  echo "pnpx: could not resolve $0 to a regular file within 40 symlink hops." >&2
-  exit 1
-fi
-
-exec "${self%/*}/pnpm" dlx "$@"
+#!/usr/bin/env node
+import './bin/pnpx.mjs'

package/pnx

@@ -1,70 +1,2 @@
-#!/bin/sh
-# `pnx` is `pnpm dlx`. The pnpm it hands over to is the one installed alongside
-# it, found relative to this file: a `PATH` lookup would run whatever other pnpm
-# comes first there, and would find nothing at all when the directory holding
-# these bins is not on `PATH`.
-#
-# $0 is whatever shim or symlink `pnx` was launched through, so walk to the file
-# itself first. The hop cap matches the kernel's ELOOP limit, so a cycle cannot
-# hang the script. Directories come from `${self%/*}` and `readlink` runs through
-# `command -p`, so the caller's `PATH` decides nothing here.
-#
-# Where no default path is compiled in, as on Nix, `command -p` searches PATH
-# instead, so the helpers run with node_modules and relative entries dropped from
-# PATH.
-caller_path_set=${PATH+set}
-caller_path=${PATH-}
-helper_path=
-rest=$caller_path:
-while [ -n "$rest" ]; do
-  dir=${rest%%:*}
-  rest=${rest#*:}
-  case "$dir" in
-    */node_modules/*|*/node_modules) ;;
-    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
-  esac
-done
-# An empty PATH searches the current directory.
-PATH=${helper_path:-/}
-self=$0
-# MSYS and Cygwin can launch this with a native Windows path, which has no slash
-# for `${self%/*}` to strip. Only a drive letter or a UNC prefix marks one; a
-# backslash anywhere else is an ordinary character in a Unix file name, so the
-# path is left alone. The separators are swapped in the shell rather than through
-# `echo`, which mangles a `\t` or `\b` in a path under dash.
-case $self in
-  [A-Za-z]:\\*|\\\\*)
-    while :; do
-      case $self in
-        *\\*) self=${self%%\\*}/${self#*\\} ;;
-        *) break ;;
-      esac
-    done
-    ;;
-esac
-# `${self%/*}` needs a slash to strip. A bare name came from a `PATH` lookup and
-# stands for a file in the current directory.
-case $self in
-  */*) ;;
-  *) self=./$self ;;
-esac
-hops=0
-while [ -L "$self" ] && [ "$hops" -lt 40 ]; do
-  hops=$((hops + 1))
-  link=$(command -p readlink "$self")
-  case $link in
-    /*) self=$link ;;
-    *) self=${self%/*}/$link ;;
-  esac
-done
-if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
-# The walk has to end at a regular file. Running out of hops leaves $self a
-# symlink; a chain that changed under us can leave it dangling or a directory, and
-# a failed readlink leaves a trailing slash. Each case would take `pnpm` from the
-# wrong directory — the substitution this script exists to prevent.
-if [ -L "$self" ] || [ ! -f "$self" ]; then
-  echo "pnx: could not resolve $0 to a regular file within 40 symlink hops." >&2
-  exit 1
-fi
-
-exec "${self%/*}/pnpm" dlx "$@"
+#!/usr/bin/env node
+import './bin/pnpx.mjs'