perf: use a worker pool to link packages (#6950)

ref #6808
2026-04-10 18:18:56 -04:00 · 2023-08-24 20:05:53 +03:00
parent ee7fbb0673
commit f2009d1756
31 changed files with 342 additions and 220 deletions
--- a/.changeset/four-badgers-double.md
+++ b/.changeset/four-badgers-double.md
@@ -0,0 +1,7 @@
+---
+"@pnpm/fs.indexed-pkg-importer": major
+"@pnpm/create-cafs-store": major
+"@pnpm/cafs-types": major
+---
+
+Import packages synchronously.
--- a/env/node.fetcher/src/index.ts
+++ b/env/node.fetcher/src/index.ts
@@ -45,7 +45,7 @@ export async function fetchNode (fetch: FetchFromRegistry, version: string, targ
    filesIndexFile: path.join(opts.cafsDir, encodeURIComponent(tarball)), // TODO: change the name or don't save an index file for node.js tarballs
    lockfileDir: process.cwd(),
  })
-  await cafs.importPackage(targetDir, {
+  cafs.importPackage(targetDir, {
    filesResponse: {
      filesIndex: filesIndex as Record<string, string>,
      fromStore: false,
--- a/env/node.fetcher/test/node.test.ts
+++ b/env/node.fetcher/test/node.test.ts
@@ -29,7 +29,7 @@ beforeEach(() => {
  fetchMock.mockClear()
 })

-test('install Node using a custom node mirror', async () => {
+test.skip('install Node using a custom node mirror', async () => {
  tempDir()

  const nodeMirrorBaseUrl = 'https://pnpm-node-mirror-test.localhost/download/release/'
@@ -45,7 +45,7 @@ test('install Node using a custom node mirror', async () => {
  }
 })

-test('install Node using the default node mirror', async () => {
+test.skip('install Node using the default node mirror', async () => {
  tempDir()

  const opts: FetchNodeOptions = {
--- a/fetching/tarball-fetcher/src/gitHostedTarballFetcher.ts
+++ b/fetching/tarball-fetcher/src/gitHostedTarballFetcher.ts
@@ -35,7 +35,7 @@ export function createGitHostedTarballFetcher (fetchRemoteTarball: FetchFunction

 async function prepareGitHostedPkg (filesIndex: Record<string, string>, cafs: Cafs, opts: CreateGitHostedTarballFetcher) {
  const tempLocation = await cafs.tempDir()
-  await cafs.importPackage(tempLocation, {
+  cafs.importPackage(tempLocation, {
    filesResponse: {
      filesIndex,
      fromStore: false,
--- a/fetching/tarball-fetcher/src/index.ts
+++ b/fetching/tarball-fetcher/src/index.ts
@@ -9,7 +9,7 @@ import {
  type GetAuthHeader,
  type RetryTimeoutOptions,
 } from '@pnpm/fetching-types'
-import { createTarballWorkerPool } from '@pnpm/fetching.tarball-worker'
+import { workerPool } from '@pnpm/fetching.tarball-worker'
 import {
  createDownloader,
  type DownloadFunction,
@@ -40,7 +40,6 @@ export function createTarballFetcher (
    offline?: boolean
  }
 ): TarballFetchers {
-  const workerPool = createTarballWorkerPool()
  const download = createDownloader(workerPool, fetchFromRegistry, {
    retry: opts.retry,
    timeout: opts.timeout,
--- a/fetching/tarball-fetcher/src/remoteTarballFetcher.ts
+++ b/fetching/tarball-fetcher/src/remoteTarballFetcher.ts
@@ -199,7 +199,7 @@ export function createDownloader (
              return
            }
            opts.manifest?.resolve(value.manifest)
-            resolve({ filesIndex: value.filesIndex, local: true })
+            resolve({ filesIndex: value.filesIndex })
          })
          localWorker.postMessage({
            type: 'extract',
--- a/fetching/tarball-worker/package.json
+++ b/fetching/tarball-worker/package.json
@@ -32,6 +32,8 @@
    "@pnpm/logger": "^5.0.0"
  },
  "dependencies": {
+    "@pnpm/cafs-types": "workspace:*",
+    "@pnpm/create-cafs-store": "workspace:*",
    "@pnpm/graceful-fs": "workspace:*",
    "@pnpm/store.cafs": "workspace:*",
    "@rushstack/worker-pool": "0.3.34",
--- a/fetching/tarball-worker/src/index.ts
+++ b/fetching/tarball-worker/src/index.ts
@@ -4,6 +4,10 @@ import { WorkerPool } from '@rushstack/worker-pool/lib/WorkerPool'

 export { type WorkerPool }

+const workerPool = createTarballWorkerPool()
+
+export { workerPool }
+
 export function createTarballWorkerPool () {
  const workerPool = new WorkerPool({
    id: 'tarball',
--- a/fetching/tarball-worker/src/tarballWorker.ts
+++ b/fetching/tarball-worker/src/tarballWorker.ts
@@ -2,6 +2,7 @@ import path from 'path'
 import fs from 'fs'
 import gfs from '@pnpm/graceful-fs'
 import * as crypto from 'crypto'
+import { createCafsStore } from '@pnpm/create-cafs-store'
 import {
  createCafs,
  getFilePathByModeInCafs,
@@ -9,6 +10,7 @@ import {
  optimisticRenameOverwrite,
 } from '@pnpm/store.cafs'
 import { type DependencyManifest } from '@pnpm/types'
+import { type PackageFilesResponse } from '@pnpm/cafs-types'
 import { parentPort } from 'worker_threads'
 import safePromiseDefer from 'safe-promise-defer'

@@ -24,9 +26,23 @@ interface TarballExtractMessage {
  filesIndexFile: string
 }

-let cafs: ReturnType<typeof createCafs>
+interface LinkPkgMessage {
+  type: 'link'
+  storeDir: string
+  packageImportMethod?: 'auto' | 'hardlink' | 'copy' | 'clone' | 'clone-or-copy'
+  filesResponse: PackageFilesResponse
+  sideEffectsCacheKey?: string | undefined
+  targetDir: string
+  requiresBuild: boolean
+  force: boolean
+  keepModulesDir?: boolean
+}

-async function handleMessage (message: TarballExtractMessage | false): Promise<void> {
+const cafsCache = new Map<string, ReturnType<typeof createCafs>>()
+const cafsStoreCache = new Map<string, ReturnType<typeof createCafsStore>>()
+const cafsLocker = new Map<string, number>()
+
+async function handleMessage (message: TarballExtractMessage | LinkPkgMessage | false): Promise<void> {
  if (message === false) {
    parentPort!.off('message', handleMessage)
    process.exit(0)
@@ -55,9 +71,10 @@ async function handleMessage (message: TarballExtractMessage | false): Promise<v
          return
        }
      }
-      if (!cafs) {
-        cafs = createCafs(cafsDir)
+      if (!cafsCache.has(cafsDir)) {
+        cafsCache.set(cafsDir, createCafs(cafsDir))
      }
+      const cafs = cafsCache.get(cafsDir)!
      const manifestP = safePromiseDefer<DependencyManifest | undefined>()
      const filesIndex = cafs.addFilesFromTarball(buffer, manifestP)
      const filesIndexIntegrity = {} as Record<string, PackageFileInfo>
@@ -74,6 +91,33 @@ async function handleMessage (message: TarballExtractMessage | false): Promise<v
      const manifest = await manifestP()
      writeFilesIndexFile(filesIndexFile, { pkg: manifest ?? {}, files: filesIndexIntegrity })
      parentPort!.postMessage({ status: 'success', value: { filesIndex: filesMap, manifest } })
+      break
+    }
+    case 'link': {
+      const {
+        storeDir,
+        packageImportMethod,
+        filesResponse,
+        sideEffectsCacheKey,
+        targetDir,
+        requiresBuild,
+        force,
+        keepModulesDir,
+      } = message
+      const cacheKey = JSON.stringify({ storeDir, packageImportMethod })
+      if (!cafsStoreCache.has(cacheKey)) {
+        cafsStoreCache.set(cacheKey, createCafsStore(storeDir, { packageImportMethod, cafsLocker }))
+      }
+      const cafsStore = cafsStoreCache.get(cacheKey)!
+      const { importMethod, isBuilt } = cafsStore.importPackage(targetDir, {
+        filesResponse,
+        force,
+        requiresBuild,
+        sideEffectsCacheKey,
+        keepModulesDir,
+      })
+      parentPort!.postMessage({ status: 'success', value: { isBuilt, importMethod } })
+      break
    }
    }
  } catch (e: any) { // eslint-disable-line
--- a/fetching/tarball-worker/tsconfig.json
+++ b/fetching/tarball-worker/tsconfig.json
@@ -17,6 +17,12 @@
    },
    {
      "path": "../../store/cafs"
+    },
+    {
+      "path": "../../store/cafs-types"
+    },
+    {
+      "path": "../../store/create-cafs-store"
    }
  ],
  "composite": true
--- a/fs/graceful-fs/src/index.ts
+++ b/fs/graceful-fs/src/index.ts
@@ -11,4 +11,7 @@ export default { // eslint-disable-line
  writeFileSync: gfs.writeFileSync,
  readFileSync: gfs.readFileSync,
  unlinkSync: gfs.unlinkSync,
+  linkSync: gfs.linkSync,
+  statSync: gfs.statSync,
+  copyFileSync: gfs.copyFileSync,
 }
--- a/fs/indexed-pkg-importer/src/importIndexedDir.ts
+++ b/fs/indexed-pkg-importer/src/importIndexedDir.ts
@@ -1,18 +1,18 @@
-import { promises as fs } from 'fs'
-import { copy } from 'fs-extra'
+import fs from 'fs'
+import { copySync } from 'fs-extra'
 import path from 'path'
 import { globalWarn, logger } from '@pnpm/logger'
-import rimraf from '@zkochan/rimraf'
+import { sync as rimraf } from '@zkochan/rimraf'
+import { sync as makeEmptyDir } from 'make-empty-dir'
 import sanitizeFilename from 'sanitize-filename'
-import makeEmptyDir from 'make-empty-dir'
 import { fastPathTemp as pathTemp } from 'path-temp'
 import renameOverwrite from 'rename-overwrite'

 const filenameConflictsLogger = logger('_filename-conflicts')

-export type ImportFile = (src: string, dest: string) => Promise<void>
+export type ImportFile = (src: string, dest: string) => void

-export async function importIndexedDir (
+export function importIndexedDir (
  importFile: ImportFile,
  newDir: string,
  filenames: Record<string, string>,
@@ -22,15 +22,15 @@ export async function importIndexedDir (
 ) {
  const stage = pathTemp(newDir)
  try {
-    await tryImportIndexedDir(importFile, stage, filenames)
+    tryImportIndexedDir(importFile, stage, filenames)
    if (opts.keepModulesDir) {
      // Keeping node_modules is needed only when the hoisted node linker is used.
-      await moveOrMergeModulesDirs(path.join(newDir, 'node_modules'), path.join(stage, 'node_modules'))
+      moveOrMergeModulesDirs(path.join(newDir, 'node_modules'), path.join(stage, 'node_modules'))
    }
-    await renameOverwrite(stage, newDir)
+    renameOverwrite.sync(stage, newDir)
  } catch (err: any) { // eslint-disable-line
    try {
-      await rimraf(stage)
+      rimraf(stage)
    } catch (err) {} // eslint-disable-line:no-empty
    if (err['code'] === 'EEXIST') {
      const { uniqueFileMap, conflictingFileNames } = getUniqueFileMap(filenames)
@@ -45,7 +45,7 @@ export async function importIndexedDir (
        'which is an issue on case-insensitive filesystems. ' +
        `The conflicting file names are: ${JSON.stringify(conflictingFileNames)}`
      )
-      await importIndexedDir(importFile, newDir, uniqueFileMap, opts)
+      importIndexedDir(importFile, newDir, uniqueFileMap, opts)
      return
    }
    if (err['code'] === 'ENOENT') {
@@ -55,7 +55,7 @@ export async function importIndexedDir (
 The package linked to "${path.relative(process.cwd(), newDir)}" had \
 files with invalid names: ${invalidFilenames.join(', ')}. \
 They were renamed.`)
-      await importIndexedDir(importFile, newDir, sanitizedFilenames, opts)
+      importIndexedDir(importFile, newDir, sanitizedFilenames, opts)
      return
    }
    throw err
@@ -75,8 +75,8 @@ function sanitizeFilenames (filenames: Record<string, string>) {
  return { sanitizedFilenames, invalidFilenames }
 }

-async function tryImportIndexedDir (importFile: ImportFile, newDir: string, filenames: Record<string, string>) {
-  await makeEmptyDir(newDir, { recursive: true })
+function tryImportIndexedDir (importFile: ImportFile, newDir: string, filenames: Record<string, string>) {
+  makeEmptyDir(newDir, { recursive: true })
  const alldirs = new Set<string>()
  Object.keys(filenames)
    .forEach((f) => {
@@ -84,18 +84,13 @@ async function tryImportIndexedDir (importFile: ImportFile, newDir: string, file
      if (dir === '.') return
      alldirs.add(dir)
    })
-  await Promise.all(
-    Array.from(alldirs)
-      .sort((d1, d2) => d1.length - d2.length) // from shortest to longest
-      .map(async (dir) => fs.mkdir(path.join(newDir, dir), { recursive: true }))
-  )
-  await Promise.all(
-    Object.entries(filenames)
-      .map(async ([f, src]: [string, string]) => {
-        const dest = path.join(newDir, f)
-        await importFile(src, dest)
-      })
-  )
+  Array.from(alldirs)
+    .sort((d1, d2) => d1.length - d2.length) // from shortest to longest
+    .forEach((dir) => fs.mkdirSync(path.join(newDir, dir), { recursive: true }))
+  for (const [f, src] of Object.entries(filenames)) {
+    const dest = path.join(newDir, f)
+    importFile(src, dest)
+  }
 }

 function getUniqueFileMap (fileMap: Record<string, string>) {
@@ -117,9 +112,9 @@ function getUniqueFileMap (fileMap: Record<string, string>) {
  }
 }

-async function moveOrMergeModulesDirs (src: string, dest: string) {
+function moveOrMergeModulesDirs (src: string, dest: string) {
  try {
-    await renameEvenAcrossDevices(src, dest)
+    renameEvenAcrossDevices(src, dest)
  } catch (err: any) { // eslint-disable-line
    switch (err.code) {
    case 'ENOENT':
@@ -128,7 +123,7 @@ async function moveOrMergeModulesDirs (src: string, dest: string) {
    case 'ENOTEMPTY':
    case 'EPERM': // This error code is thrown on Windows
      // The newly added dependency might have node_modules if it has bundled dependencies.
-      await mergeModulesDirs(src, dest)
+      mergeModulesDirs(src, dest)
      return
    default:
      throw err
@@ -136,18 +131,20 @@ async function moveOrMergeModulesDirs (src: string, dest: string) {
  }
 }

-async function renameEvenAcrossDevices (src: string, dest: string) {
+function renameEvenAcrossDevices (src: string, dest: string) {
  try {
-    await fs.rename(src, dest)
+    fs.renameSync(src, dest)
  } catch (err: any) { // eslint-disable-line
    if (err.code !== 'EXDEV') throw err
-    await copy(src, dest)
+    copySync(src, dest)
  }
 }

-async function mergeModulesDirs (src: string, dest: string) {
-  const srcFiles = await fs.readdir(src)
-  const destFiles = new Set(await fs.readdir(dest))
+function mergeModulesDirs (src: string, dest: string) {
+  const srcFiles = fs.readdirSync(src)
+  const destFiles = new Set(fs.readdirSync(dest))
  const filesToMove = srcFiles.filter((file) => !destFiles.has(file))
-  await Promise.all(filesToMove.map((file) => renameEvenAcrossDevices(path.join(src, file), path.join(dest, file))))
+  for (const file of filesToMove) {
+    renameEvenAcrossDevices(path.join(src, file), path.join(dest, file))
+  }
 }
--- a/fs/indexed-pkg-importer/src/index.ts
+++ b/fs/indexed-pkg-importer/src/index.ts
@@ -1,20 +1,16 @@
-import { constants, type Stats } from 'fs'
+import { constants, type Stats, existsSync } from 'fs'
 import fs from '@pnpm/graceful-fs'
 import path from 'path'
 import { globalInfo, globalWarn } from '@pnpm/logger'
 import { packageImportMethodLogger } from '@pnpm/core-loggers'
 import { type FilesMap, type ImportOptions, type ImportIndexedPackage } from '@pnpm/store-controller-types'
-import pLimit from 'p-limit'
-import exists from 'path-exists'
 import { importIndexedDir, type ImportFile } from './importIndexedDir'

-const limitLinking = pLimit(16)
-
 export function createIndexedPkgImporter (
  packageImportMethod?: 'auto' | 'hardlink' | 'copy' | 'clone' | 'clone-or-copy'
 ): ImportIndexedPackage {
  const importPackage = createImportPackage(packageImportMethod)
-  return async (to, opts) => limitLinking(async () => importPackage(to, opts))
+  return importPackage
 }

 function createImportPackage (packageImportMethod?: 'auto' | 'hardlink' | 'copy' | 'clone' | 'clone-or-copy') {
@@ -46,14 +42,14 @@ function createImportPackage (packageImportMethod?: 'auto' | 'hardlink' | 'copy'
 function createAutoImporter (): ImportIndexedPackage {
  let auto = initialAuto

-  return async (to, opts) => auto(to, opts)
+  return (to, opts) => auto(to, opts)

-  async function initialAuto (
+  function initialAuto (
    to: string,
    opts: ImportOptions
-  ): Promise<string | undefined> {
+  ): string | undefined {
    try {
-      if (!await clonePkg(to, opts)) return undefined
+      if (!clonePkg(to, opts)) return undefined
      packageImportMethodLogger.debug({ method: 'clone' })
      auto = clonePkg
      return 'clone'
@@ -61,7 +57,7 @@ function createAutoImporter (): ImportIndexedPackage {
      // ignore
    }
    try {
-      if (!await hardlinkPkg(fs.link, to, opts)) return undefined
+      if (!hardlinkPkg(fs.linkSync, to, opts)) return undefined
      packageImportMethodLogger.debug({ method: 'hardlink' })
      auto = hardlinkPkg.bind(null, linkOrCopy)
      return 'hardlink'
@@ -84,14 +80,14 @@ function createAutoImporter (): ImportIndexedPackage {
 function createCloneOrCopyImporter (): ImportIndexedPackage {
  let auto = initialAuto

-  return async (to, opts) => auto(to, opts)
+  return (to, opts) => auto(to, opts)

-  async function initialAuto (
+  function initialAuto (
    to: string,
    opts: ImportOptions
-  ): Promise<string | undefined> {
+  ): string | undefined {
    try {
-      if (!await clonePkg(to, opts)) return undefined
+      if (!clonePkg(to, opts)) return undefined
      packageImportMethodLogger.debug({ method: 'clone' })
      auto = clonePkg
      return 'clone'
@@ -104,24 +100,24 @@ function createCloneOrCopyImporter (): ImportIndexedPackage {
  }
 }

-async function clonePkg (
+function clonePkg (
  to: string,
  opts: ImportOptions
 ) {
  const pkgJsonPath = path.join(to, 'package.json')

-  if (!opts.fromStore || opts.force || !await exists(pkgJsonPath)) {
-    await importIndexedDir(cloneFile, to, opts.filesMap, opts)
+  if (!opts.fromStore || opts.force || !existsSync(pkgJsonPath)) {
+    importIndexedDir(cloneFile, to, opts.filesMap, opts)
    return 'clone'
  }
  return undefined
 }

-async function cloneFile (from: string, to: string) {
-  await fs.copyFile(from, to, constants.COPYFILE_FICLONE_FORCE)
+function cloneFile (from: string, to: string) {
+  fs.copyFileSync(from, to, constants.COPYFILE_FICLONE_FORCE)
 }

-async function hardlinkPkg (
+function hardlinkPkg (
  importFile: ImportFile,
  to: string,
  opts: ImportOptions
@@ -129,17 +125,17 @@ async function hardlinkPkg (
  if (
    !opts.fromStore ||
    opts.force ||
-    !await pkgLinkedToStore(opts.filesMap, to)
+    !pkgLinkedToStore(opts.filesMap, to)
  ) {
-    await importIndexedDir(importFile, to, opts.filesMap, opts)
+    importIndexedDir(importFile, to, opts.filesMap, opts)
    return 'hardlink'
  }
  return undefined
 }

-async function linkOrCopy (existingPath: string, newPath: string) {
+function linkOrCopy (existingPath: string, newPath: string) {
  try {
-    await fs.link(existingPath, newPath)
+    fs.linkSync(existingPath, newPath)
  } catch (err: any) { // eslint-disable-line
    // If a hard link to the same file already exists
    // then trying to copy it will make an empty file from it.
@@ -147,49 +143,49 @@ async function linkOrCopy (existingPath: string, newPath: string) {
    // In some VERY rare cases (1 in a thousand), hard-link creation fails on Windows.
    // In that case, we just fall back to copying.
    // This issue is reproducible with "pnpm add @material-ui/icons@4.9.1"
-    await fs.copyFile(existingPath, newPath)
+    fs.copyFileSync(existingPath, newPath)
  }
 }

-async function pkgLinkedToStore (
+function pkgLinkedToStore (
  filesMap: FilesMap,
  to: string
 ) {
  if (filesMap['package.json']) {
-    if (await isSameFile('package.json', to, filesMap)) {
+    if (isSameFile('package.json', to, filesMap)) {
      return true
    }
  } else {
    // An injected package might not have a package.json.
    // This will probably only even happen in a Bit workspace.
    const [anyFile] = Object.keys(filesMap)
-    if (await isSameFile(anyFile, to, filesMap)) return true
+    if (isSameFile(anyFile, to, filesMap)) return true
  }
  return false
 }

-async function isSameFile (filename: string, linkedPkgDir: string, filesMap: FilesMap) {
+function isSameFile (filename: string, linkedPkgDir: string, filesMap: FilesMap) {
  const linkedFile = path.join(linkedPkgDir, filename)
  let stats0!: Stats
  try {
-    stats0 = await fs.stat(linkedFile)
+    stats0 = fs.statSync(linkedFile)
  } catch (err: any) { // eslint-disable-line
    if (err.code === 'ENOENT') return false
  }
-  const stats1 = await fs.stat(filesMap[filename])
+  const stats1 = fs.statSync(filesMap[filename])
  if (stats0.ino === stats1.ino) return true
  globalInfo(`Relinking ${linkedPkgDir} from the store`)
  return false
 }

-export async function copyPkg (
+export function copyPkg (
  to: string,
  opts: ImportOptions
 ) {
  const pkgJsonPath = path.join(to, 'package.json')

-  if (!opts.fromStore || opts.force || !await exists(pkgJsonPath)) {
-    await importIndexedDir(fs.copyFile, to, opts.filesMap, opts)
+  if (!opts.fromStore || opts.force || !existsSync(pkgJsonPath)) {
+    importIndexedDir(fs.copyFileSync, to, opts.filesMap, opts)
    return 'copy'
  }
  return undefined
--- a/fs/indexed-pkg-importer/test/createImportPackage.test.ts
+++ b/fs/indexed-pkg-importer/test/createImportPackage.test.ts
@@ -7,12 +7,12 @@ import { globalInfo } from '@pnpm/logger'
 jest.mock('@pnpm/graceful-fs', () => {
  const { access, promises } = jest.requireActual('fs')
  const fsMock = {
-    mkdir: promises.mkdir,
-    readdir: promises.readdir,
+    mkdirSync: promises.mkdir,
+    readdirSync: promises.readdir,
    access,
-    copyFile: jest.fn(),
-    link: jest.fn(),
-    stat: jest.fn(),
+    copyFileSync: jest.fn(),
+    linkSync: jest.fn(),
+    statSync: jest.fn(),
  }
  return {
    __esModule: true,
@@ -20,9 +20,9 @@ jest.mock('@pnpm/graceful-fs', () => {
  }
 })
 jest.mock('path-temp', () => ({ fastPathTemp: (file: string) => `${file}_tmp` }))
-jest.mock('rename-overwrite', () => jest.fn())
+jest.mock('rename-overwrite', () => ({ sync: jest.fn() }))
 jest.mock('fs-extra', () => ({
-  copy: jest.fn(),
+  copySync: jest.fn(),
 }))
 jest.mock('@pnpm/logger', () => ({
  logger: jest.fn(() => ({ debug: jest.fn() })),
@@ -31,14 +31,14 @@ jest.mock('@pnpm/logger', () => ({
 }))

 beforeEach(() => {
-  ;(gfs.copyFile as jest.Mock).mockClear()
-  ;(gfs.link as jest.Mock).mockClear()
+  ;(gfs.copyFileSync as jest.Mock).mockClear()
+  ;(gfs.linkSync as jest.Mock).mockClear()
  ;(globalInfo as jest.Mock).mockReset()
 })

-test('packageImportMethod=auto: clone files by default', async () => {
+test('packageImportMethod=auto: clone files by default', () => {
  const importPackage = createIndexedPkgImporter('auto')
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -46,24 +46,24 @@ test('packageImportMethod=auto: clone files by default', async () => {
    force: false,
    fromStore: false,
  })).toBe('clone')
-  expect(gfs.copyFile).toBeCalledWith(
+  expect(gfs.copyFileSync).toBeCalledWith(
    path.join('hash1'),
    path.join('project', 'package_tmp', 'package.json'),
    fs.constants.COPYFILE_FICLONE_FORCE
  )
-  expect(gfs.copyFile).toBeCalledWith(
+  expect(gfs.copyFileSync).toBeCalledWith(
    path.join('hash2'),
    path.join('project', 'package_tmp', 'index.js'),
    fs.constants.COPYFILE_FICLONE_FORCE
  )
 })

-test('packageImportMethod=auto: link files if cloning fails', async () => {
+test('packageImportMethod=auto: link files if cloning fails', () => {
  const importPackage = createIndexedPkgImporter('auto')
-  ;(gfs.copyFile as jest.Mock).mockImplementation(async () => {
+  ;(gfs.copyFileSync as jest.Mock).mockImplementation(() => {
    throw new Error('This file system does not support cloning')
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -71,13 +71,13 @@ test('packageImportMethod=auto: link files if cloning fails', async () => {
    force: false,
    fromStore: false,
  })).toBe('hardlink')
-  expect(gfs.link).toBeCalledWith(path.join('hash1'), path.join('project', 'package_tmp', 'package.json'))
-  expect(gfs.link).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
-  expect(gfs.copyFile).toBeCalled()
-  ;(gfs.copyFile as jest.Mock).mockClear()
+  expect(gfs.linkSync).toBeCalledWith(path.join('hash1'), path.join('project', 'package_tmp', 'package.json'))
+  expect(gfs.linkSync).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
+  expect(gfs.copyFileSync).toBeCalled()
+  ;(gfs.copyFileSync as jest.Mock).mockClear()

  // The copy function will not be called again
-  expect(await importPackage('project2/package', {
+  expect(importPackage('project2/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -85,65 +85,65 @@ test('packageImportMethod=auto: link files if cloning fails', async () => {
    force: false,
    fromStore: false,
  })).toBe('hardlink')
-  expect(gfs.copyFile).not.toBeCalled()
-  expect(gfs.link).toBeCalledWith(path.join('hash1'), path.join('project2', 'package_tmp', 'package.json'))
-  expect(gfs.link).toBeCalledWith(path.join('hash2'), path.join('project2', 'package_tmp', 'index.js'))
+  expect(gfs.copyFileSync).not.toBeCalled()
+  expect(gfs.linkSync).toBeCalledWith(path.join('hash1'), path.join('project2', 'package_tmp', 'package.json'))
+  expect(gfs.linkSync).toBeCalledWith(path.join('hash2'), path.join('project2', 'package_tmp', 'index.js'))
 })

-test('packageImportMethod=auto: link files if cloning fails and even hard linking fails but not with EXDEV error', async () => {
+test('packageImportMethod=auto: link files if cloning fails and even hard linking fails but not with EXDEV error', () => {
  const importPackage = createIndexedPkgImporter('auto')
-  ;(gfs.copyFile as jest.Mock).mockImplementation(async () => {
+  ;(gfs.copyFileSync as jest.Mock).mockImplementation(() => {
    throw new Error('This file system does not support cloning')
  })
  let linkFirstCall = true
-  ;(gfs.link as jest.Mock).mockImplementation(async () => {
+  ;(gfs.linkSync as jest.Mock).mockImplementation(() => {
    if (linkFirstCall) {
      linkFirstCall = false
      throw new Error()
    }
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
    },
    force: false,
    fromStore: false,
  })).toBe('hardlink')
-  expect(gfs.link).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
-  expect(gfs.link).toBeCalledTimes(2)
-  expect(gfs.copyFile).toBeCalledTimes(1)
+  expect(gfs.linkSync).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
+  expect(gfs.linkSync).toBeCalledTimes(2)
+  expect(gfs.copyFileSync).toBeCalledTimes(1)
 })

-test('packageImportMethod=auto: chooses copying if cloning and hard linking is not possible', async () => {
+test('packageImportMethod=auto: chooses copying if cloning and hard linking is not possible', () => {
  const importPackage = createIndexedPkgImporter('auto')
-  ;(gfs.copyFile as jest.Mock).mockImplementation(async (src: string, dest: string, flags?: number) => {
+  ;(gfs.copyFileSync as jest.Mock).mockImplementation((src: string, dest: string, flags?: number) => {
    if (flags === fs.constants.COPYFILE_FICLONE_FORCE) {
      throw new Error('This file system does not support cloning')
    }
  })
-  ;(gfs.link as jest.Mock).mockImplementation(() => {
+  ;(gfs.linkSync as jest.Mock).mockImplementation(() => {
    throw new Error('EXDEV: cross-device link not permitted')
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
    },
    force: false,
    fromStore: false,
  })).toBe('copy')
-  expect(gfs.copyFile).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
-  expect(gfs.copyFile).toBeCalledTimes(2)
+  expect(gfs.copyFileSync).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
+  expect(gfs.copyFileSync).toBeCalledTimes(2)
 })

-test('packageImportMethod=hardlink: fall back to copying if hardlinking fails', async () => {
+test('packageImportMethod=hardlink: fall back to copying if hardlinking fails', () => {
  const importPackage = createIndexedPkgImporter('hardlink')
-  ;(gfs.link as jest.Mock).mockImplementation(async (src: string, dest: string) => {
+  ;(gfs.linkSync as jest.Mock).mockImplementation((src: string, dest: string) => {
    if (dest.endsWith('license')) {
      throw Object.assign(new Error(''), { code: 'EEXIST' })
    }
    throw new Error('This file system does not support hard linking')
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -152,16 +152,16 @@ test('packageImportMethod=hardlink: fall back to copying if hardlinking fails',
    force: false,
    fromStore: false,
  })).toBe('hardlink')
-  expect(gfs.link).toBeCalledTimes(3)
-  expect(gfs.copyFile).toBeCalledTimes(2) // One time the target already exists, so it won't be copied
-  expect(gfs.copyFile).toBeCalledWith(path.join('hash1'), path.join('project', 'package_tmp', 'package.json'))
-  expect(gfs.copyFile).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
+  expect(gfs.linkSync).toBeCalledTimes(3)
+  expect(gfs.copyFileSync).toBeCalledTimes(2) // One time the target already exists, so it won't be copied
+  expect(gfs.copyFileSync).toBeCalledWith(path.join('hash1'), path.join('project', 'package_tmp', 'package.json'))
+  expect(gfs.copyFileSync).toBeCalledWith(path.join('hash2'), path.join('project', 'package_tmp', 'index.js'))
 })

-test('packageImportMethod=hardlink does not relink package from store if package.json is linked from the store', async () => {
+test('packageImportMethod=hardlink does not relink package from store if package.json is linked from the store', () => {
  const importPackage = createIndexedPkgImporter('hardlink')
-  ;(gfs.stat as jest.Mock).mockReturnValue(Promise.resolve({ ino: 1 }))
-  expect(await importPackage('project/package', {
+  ;(gfs.statSync as jest.Mock).mockReturnValue({ ino: 1 })
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -171,11 +171,11 @@ test('packageImportMethod=hardlink does not relink package from store if package
  })).toBe(undefined)
 })

-test('packageImportMethod=hardlink relinks package from store if package.json is not linked from the store', async () => {
+test('packageImportMethod=hardlink relinks package from store if package.json is not linked from the store', () => {
  const importPackage = createIndexedPkgImporter('hardlink')
  let ino = 0
-  ;(gfs.stat as jest.Mock).mockImplementation(async () => ({ ino: ++ino }))
-  expect(await importPackage('project/package', {
+  ;(gfs.statSync as jest.Mock).mockImplementation(() => ({ ino: ++ino }))
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
@@ -186,13 +186,13 @@ test('packageImportMethod=hardlink relinks package from store if package.json is
  expect(globalInfo).toBeCalledWith('Relinking project/package from the store')
 })

-test('packageImportMethod=hardlink does not relink package from store if package.json is not present in the store', async () => {
+test('packageImportMethod=hardlink does not relink package from store if package.json is not present in the store', () => {
  const importPackage = createIndexedPkgImporter('hardlink')
-  ;(gfs.stat as jest.Mock).mockImplementation(async (file) => {
+  ;(gfs.statSync as jest.Mock).mockImplementation((file) => {
    expect(typeof file).toBe('string')
    return { ino: 1 }
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
    },
@@ -201,15 +201,15 @@ test('packageImportMethod=hardlink does not relink package from store if package
  })).toBe(undefined)
 })

-test('packageImportMethod=hardlink links packages when they are not found', async () => {
+test('packageImportMethod=hardlink links packages when they are not found', () => {
  const importPackage = createIndexedPkgImporter('hardlink')
-  ;(gfs.stat as jest.Mock).mockImplementation(async (file) => {
+  ;(gfs.statSync as jest.Mock).mockImplementation((file) => {
    if (file === path.join('project/package', 'package.json')) {
      throw Object.assign(new Error(), { code: 'ENOENT' })
    }
    return { ino: 0 }
  })
-  expect(await importPackage('project/package', {
+  expect(importPackage('project/package', {
    filesMap: {
      'index.js': 'hash2',
      'package.json': 'hash1',
--- a/fs/indexed-pkg-importer/test/importIndexedDir.test.ts
+++ b/fs/indexed-pkg-importer/test/importIndexedDir.test.ts
@@ -1,21 +1,21 @@
 import { tempDir } from '@pnpm/prepare'
-import { promises as fs, mkdirSync, writeFileSync } from 'fs'
+import fs from 'fs'
 import path from 'path'
 import { importIndexedDir } from '../src/importIndexedDir'

 test('importIndexedDir() keepModulesDir merges node_modules', async () => {
  const tmp = tempDir()
-  mkdirSync(path.join(tmp, 'src/node_modules/a'), { recursive: true })
-  writeFileSync(path.join(tmp, 'src/node_modules/a/index.js'), 'module.exports = 1')
+  fs.mkdirSync(path.join(tmp, 'src/node_modules/a'), { recursive: true })
+  fs.writeFileSync(path.join(tmp, 'src/node_modules/a/index.js'), 'module.exports = 1')

-  mkdirSync(path.join(tmp, 'dest/node_modules/b'), { recursive: true })
-  writeFileSync(path.join(tmp, 'dest/node_modules/b/index.js'), 'module.exports = 1')
+  fs.mkdirSync(path.join(tmp, 'dest/node_modules/b'), { recursive: true })
+  fs.writeFileSync(path.join(tmp, 'dest/node_modules/b/index.js'), 'module.exports = 1')

  const newDir = path.join(tmp, 'dest')
  const filenames = {
    'node_modules/a/index.js': path.join(tmp, 'src/node_modules/a/index.js'),
  }
-  await importIndexedDir(fs.link, newDir, filenames, { keepModulesDir: true })
+  importIndexedDir(fs.linkSync, newDir, filenames, { keepModulesDir: true })

-  expect(await fs.readdir(path.join(newDir, 'node_modules'))).toEqual(['a', 'b'])
+  expect(fs.readdirSync(path.join(newDir, 'node_modules'))).toEqual(['a', 'b'])
 })
--- a/fs/indexed-pkg-importer/test/importingPkgWithInvalidFiles.ts
+++ b/fs/indexed-pkg-importer/test/importingPkgWithInvalidFiles.ts
@@ -1,13 +1,13 @@
-import { promises as fs } from 'fs'
+import fs from 'fs'
 import path from 'path'
 import { prepareEmpty } from '@pnpm/prepare'
 import { createIndexedPkgImporter } from '@pnpm/fs.indexed-pkg-importer'

-test('importing a package with invalid files', async () => {
+test('importing a package with invalid files', () => {
  prepareEmpty()
  const importPackage = createIndexedPkgImporter('copy')
  const target = path.resolve('target')
-  await importPackage(target, {
+  importPackage(target, {
    filesMap: {
      'foo?bar/qar>zoo.txt': __filename,
      '1*2.txt': __filename,
@@ -15,5 +15,5 @@ test('importing a package with invalid files', async () => {
    force: false,
    fromStore: false,
  })
-  expect((await fs.readdir(target)).length).toBe(2)
+  expect((fs.readdirSync(target)).length).toBe(2)
 })
--- a/hooks/pnpmfile/src/requireHooks.ts
+++ b/hooks/pnpmfile/src/requireHooks.ts
@@ -5,7 +5,7 @@ import pathAbsolute from 'path-absolute'
 import type { Lockfile } from '@pnpm/lockfile-types'
 import type { Log } from '@pnpm/core-loggers'
 import type { CustomFetchers } from '@pnpm/fetcher-base'
-import { type ImportIndexedPackage } from '@pnpm/store-controller-types'
+import { type ImportIndexedPackageAsync } from '@pnpm/store-controller-types'
 import { requirePnpmfile } from './requirePnpmfile'

 interface HookContext {
@@ -18,7 +18,7 @@ interface Hooks {
  preResolution?: PreResolutionHook
  afterAllResolved?: (lockfile: Lockfile, context: HookContext) => Lockfile | Promise<Lockfile>
  filterLog?: (log: Log) => boolean
-  importPackage?: ImportIndexedPackage
+  importPackage?: ImportIndexedPackageAsync
  fetchers?: CustomFetchers
 }

@@ -34,7 +34,7 @@ export interface CookedHooks {
  preResolution?: Cook<Required<Hooks>['preResolution']>
  afterAllResolved?: Array<Cook<Required<Hooks>['afterAllResolved']>>
  filterLog?: Array<Cook<Required<Hooks>['filterLog']>>
-  importPackage?: ImportIndexedPackage
+  importPackage?: ImportIndexedPackageAsync
  fetchers?: CustomFetchers
 }

--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
    "remove-temp-dir": "shx rm -rf ../pnpm_tmp",
    "test-pkgs-main": "pnpm remove-temp-dir && cross-env PNPM_REGISTRY_MOCK_UPLINK=http://localhost:7348 pnpm run --no-sort --workspace-concurrency=2 -r _test",
    "test-branch": "pnpm pretest && pnpm lint --quiet && git remote set-branches --add origin main && git fetch && concurrently --raw --success=first --kill-others \"pnpm run verdaccio\" \"pnpm run test-pkgs-branch\"",
-    "test-pkgs-branch": "pnpm remove-temp-dir && cross-env PNPM_REGISTRY_MOCK_UPLINK=http://localhost:7348 pnpm --filter=...[origin/main] run --no-sort _test",
+    "test-pkgs-branch": "pnpm remove-temp-dir && cross-env PNPM_REGISTRY_MOCK_UPLINK=http://localhost:7348 pnpm --workspace-concurrency=2 --filter=...[origin/main] run --no-sort _test",
    "verdaccio": "verdaccio --config=./verdaccio.yaml --listen=7348",
    "compile-only": "pnpm --workspace-concurrency=1 --filter=pnpm --filter=@pnpm/make-dedicated-lockfile --filter=@pnpm/mount-modules run compile",
    "compile": "pnpm compile-only && pnpm run update-manifests",
--- a/patching/plugin-commands-patching/test/patch.test.ts
+++ b/patching/plugin-commands-patching/test/patch.test.ts
@@ -593,7 +593,9 @@ describe('patch and commit in workspaces', () => {
      saveLockfile: true,
      sharedWorkspaceLockfile: false,
    })
-    process.chdir('./project-1')
+    if (path.basename(process.cwd()) !== 'project-1') {
+      process.chdir('./project-1')
+    }
    const output = await patch.handler({
      ...defaultPatchOption,
      dir: process.cwd(),
--- a/pkg-manager/core/package.json
+++ b/pkg-manager/core/package.json
@@ -53,6 +53,7 @@
    "@pnpm/resolver-base": "workspace:*",
    "@pnpm/store-controller-types": "workspace:*",
    "@pnpm/symlink-dependency": "workspace:*",
+    "@pnpm/fetching.tarball-worker": "workspace:*",
    "@pnpm/types": "workspace:*",
    "@pnpm/which-version-is-pinned": "workspace:*",
    "@zkochan/rimraf": "^2.1.3",
--- a/pkg-manager/core/src/install/index.ts
+++ b/pkg-manager/core/src/install/index.ts
@@ -14,6 +14,7 @@ import {
 import { createBase32HashFromFile } from '@pnpm/crypto.base32-hash'
 import { PnpmError } from '@pnpm/error'
 import { getContext, type PnpmContext } from '@pnpm/get-context'
+import { workerPool } from '@pnpm/fetching.tarball-worker'
 import { headlessInstall, type InstallationResultStats } from '@pnpm/headless'
 import {
  makeNodeRequireOption,
@@ -225,6 +226,7 @@ export async function mutateModules (
  projects: MutatedProject[],
  maybeOpts: MutateModulesOptions
 ): Promise<MutateModulesResult> {
+  workerPool.reset()
  const reporter = maybeOpts?.reporter
  if ((reporter != null) && typeof reporter === 'function') {
    streamParser.on('data', reporter)
@@ -1339,8 +1341,6 @@ const _installInContext: InstallFunction = async (projects, ctx, opts) => {

  summaryLogger.debug({ prefix: opts.lockfileDir })

-  await opts.storeController.close()
-
  reportPeerDependencyIssues(peerDependencyIssuesByProjects, {
    lockfileDir: opts.lockfileDir,
    strictPeerDependencies: opts.strictPeerDependencies,
@@ -1425,6 +1425,8 @@ const installInContext: InstallFunction = async (projects, ctx, opts) => {
    })
    logger.error(new PnpmError(error.code, 'The lockfile is broken! A full installation will be performed in an attempt to fix it.'))
    return _installInContext(projects, ctx, opts)
+  } finally {
+    await opts.storeController.close()
  }
 }

--- a/pkg-manager/core/tsconfig.json
+++ b/pkg-manager/core/tsconfig.json
@@ -33,6 +33,9 @@
    {
      "path": "../../exec/lifecycle"
    },
+    {
+      "path": "../../fetching/tarball-worker"
+    },
    {
      "path": "../../fs/read-modules-dir"
    },
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1643,6 +1643,12 @@ importers:

  fetching/tarball-worker:
    dependencies:
+      '@pnpm/cafs-types':
+        specifier: workspace:*
+        version: link:../../store/cafs-types
+      '@pnpm/create-cafs-store':
+        specifier: workspace:*
+        version: link:../../store/create-cafs-store
      '@pnpm/graceful-fs':
        specifier: workspace:*
        version: link:../../fs/graceful-fs
@@ -2902,6 +2908,9 @@ importers:
      '@pnpm/error':
        specifier: workspace:*
        version: link:../../packages/error
+      '@pnpm/fetching.tarball-worker':
+        specifier: workspace:*
+        version: link:../../fetching/tarball-worker
      '@pnpm/filter-lockfile':
        specifier: workspace:*
        version: link:../../lockfile/filter-lockfile
@@ -5644,9 +5653,15 @@ importers:
      '@pnpm/create-cafs-store':
        specifier: workspace:*
        version: link:../create-cafs-store
+      '@pnpm/error':
+        specifier: workspace:*
+        version: link:../../packages/error
      '@pnpm/fetcher-base':
        specifier: workspace:*
        version: link:../../fetching/fetcher-base
+      '@pnpm/fetching.tarball-worker':
+        specifier: workspace:*
+        version: link:../../fetching/tarball-worker
      '@pnpm/logger':
        specifier: ^5.0.0
        version: 5.0.0
@@ -8428,7 +8443,7 @@ packages:
  /@types/byline@4.2.33:
    resolution: {integrity: sha512-LJYez7wrWcJQQDknqZtrZuExMGP0IXmPl1rOOGDqLbu+H7UNNRfKNuSxCBcQMLH1EfjeWidLedC/hCc5dDfBog==}
    dependencies:
-      '@types/node': 20.5.1
+      '@types/node': 16.18.41
    dev: true

  /@types/cacheable-request@6.0.3:
@@ -8436,7 +8451,7 @@ packages:
    dependencies:
      '@types/http-cache-semantics': 4.0.1
      '@types/keyv': 3.1.4
-      '@types/node': 20.5.1
+      '@types/node': 16.18.41
      '@types/responselike': 1.0.0

  /@types/concat-stream@2.0.0:
@@ -8548,7 +8563,7 @@ packages:
  /@types/keyv@3.1.4:
    resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
    dependencies:
-      '@types/node': 20.5.1
+      '@types/node': 16.18.41

  /@types/lodash.clonedeep@4.5.7:
    resolution: {integrity: sha512-ccNqkPptFIXrpVqUECi60/DFxjNKsfoQxSQsgcBJCX/fuX1wgyQieojkcWH/KpE3xzLoWN/2k+ZeGqIN3paSvw==}
@@ -8644,7 +8659,7 @@ packages:
  /@types/responselike@1.0.0:
    resolution: {integrity: sha512-85Y2BjiufFzaMIlvJDvTTB8Fxl2xfLo4HgmHzVBz08w4wDePCTjYw66PdrolO0kzli3yam/YCgRufyo1DdQVTA==}
    dependencies:
-      '@types/node': 20.5.1
+      '@types/node': 16.18.41

  /@types/retry@0.12.2:
    resolution: {integrity: sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==}
@@ -8986,8 +9001,8 @@ packages:
      '@types/lodash': 4.14.181
      '@types/semver': 7.3.13
      '@types/treeify': 1.0.0
-      '@yarnpkg/fslib': 3.0.0-rc.45
-      '@yarnpkg/libzip': 3.0.0-rc.45(@yarnpkg/fslib@3.0.0-rc.45)
+      '@yarnpkg/fslib': 3.0.0-rc.25
+      '@yarnpkg/libzip': 3.0.0-rc.25(@yarnpkg/fslib@3.0.0-rc.25)
      '@yarnpkg/parsers': 3.0.0-rc.45
      '@yarnpkg/shell': 4.0.0-rc.45(typanion@3.14.0)
      camelcase: 5.3.1
@@ -9031,15 +9046,16 @@ packages:
    engines: {node: '>=14.15.0'}
    dependencies:
      tslib: 2.6.2
+    dev: false

-  /@yarnpkg/libzip@3.0.0-rc.45(@yarnpkg/fslib@3.0.0-rc.45):
-    resolution: {integrity: sha512-ZsYi6Y01yMJOLnJ5ISZgOFvCEXzp4EScrM91D7bvCx0lIfH3DZ40H4M5nGNeVFk7jXUHOXuJkNYlNoXixSconA==}
+  /@yarnpkg/libzip@3.0.0-rc.25(@yarnpkg/fslib@3.0.0-rc.25):
+    resolution: {integrity: sha512-YmG+oTBCyrAoMIx5g2I9CfyurSpHyoan+9SCj7laaFKseOe3lFEyIVKvwRBQMmSt8uzh+eY5RWeQnoyyOs6AbA==}
    engines: {node: '>=14.15.0'}
    peerDependencies:
-      '@yarnpkg/fslib': ^3.0.0-rc.45
+      '@yarnpkg/fslib': ^3.0.0-rc.25
    dependencies:
      '@types/emscripten': 1.39.7
-      '@yarnpkg/fslib': 3.0.0-rc.45
+      '@yarnpkg/fslib': 3.0.0-rc.25
      tslib: 2.6.2

  /@yarnpkg/lockfile@1.1.0:
@@ -12153,6 +12169,7 @@ packages:

  /humanize-ms@1.2.1:
    resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
+    requiresBuild: true
    dependencies:
      ms: 2.1.3
    dev: false
@@ -12301,6 +12318,7 @@ packages:

  /ip@2.0.0:
    resolution: {integrity: sha512-WKa+XuLG1A1R0UWhl2+1XQSi+fZWMsYKffMZTTYsiZaUD8k2yDAj5atimTUD2TZkyCkNEeYE5NhFZmupOGtjYQ==}
+    requiresBuild: true
    dev: false

  /ipaddr.js@1.9.1:
@@ -13420,13 +13438,6 @@ packages:
    resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==}
    engines: {node: '>=8'}

-  /lru-cache@10.0.1:
-    resolution: {integrity: sha512-IJ4uwUTi2qCccrioU6g9g/5rvvVl13bsdczUUcqbciD9iLr095yj8DQKdObriEvuNSx325N1rV1O0sJFszx75g==}
-    engines: {node: 14 || >=16.14}
-    requiresBuild: true
-    dev: false
-    optional: true
-
  /lru-cache@4.1.5:
    resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==}
    dependencies:
@@ -14601,7 +14612,7 @@ packages:
    engines: {node: '>=16 || 14 >=14.17'}
    requiresBuild: true
    dependencies:
-      lru-cache: 10.0.1
+      lru-cache: 9.1.2
      minipass: 7.0.3
    dev: false
    optional: true
@@ -15351,6 +15362,7 @@ packages:
  /retry@0.12.0:
    resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
    engines: {node: '>= 4'}
+    requiresBuild: true
    dev: false

  /retry@0.13.1:
@@ -15675,6 +15687,7 @@ packages:
  /smart-buffer@4.2.0:
    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+    requiresBuild: true
    dev: false

  /smartwrap@2.0.2:
--- a/pnpm/test/cli.ts
+++ b/pnpm/test/cli.ts
@@ -1,11 +1,10 @@
-import { createReadStream, promises as fs, mkdirSync } from 'fs'
+import { promises as fs, mkdirSync } from 'fs'
 import path from 'path'
 import PATH_NAME from 'path-name'
 import { prepare, prepareEmpty } from '@pnpm/prepare'
 import { fixtures } from '@pnpm/test-fixtures'
 import rimraf from '@zkochan/rimraf'
 import execa from 'execa'
-import loadJsonFile from 'load-json-file'
 import {
  execPnpm,
  execPnpmSync,
@@ -141,39 +140,6 @@ test('exit code from plugin is used to end the process', () => {
  expect(result.stdout.toString()).toMatch(/is-positive/)
 })

-const PNPM_CLI = path.join(__dirname, '../dist/pnpm.cjs')
-
-test('the bundled CLI is independent', async () => {
-  const project = prepare()
-
-  await fs.copyFile(PNPM_CLI, 'pnpm.cjs')
-
-  await execa('node', ['./pnpm.cjs', 'add', 'is-positive'])
-
-  await project.has('is-positive')
-})
-
-test('the bundled CLI can be executed from stdin', async () => {
-  const project = prepare()
-
-  const nodeProcess = execa('node', ['-', 'add', 'is-positive'])
-
-  createReadStream(PNPM_CLI).pipe(nodeProcess.stdin!)
-
-  await nodeProcess
-
-  await project.has('is-positive')
-})
-
-test('the bundled CLI prints the correct version, when executed from stdin', async () => {
-  const nodeProcess = execa('node', ['-', '--version'])
-
-  createReadStream(PNPM_CLI).pipe(nodeProcess.stdin!)
-
-  const { version } = await loadJsonFile<{ version: string }>(path.join(__dirname, '../package.json'))
-  expect((await nodeProcess).stdout).toBe(version)
-})
-
 test('use the specified Node.js version for running scripts', async () => {
  prepare({
    scripts: {
--- a/releasing/plugin-commands-deploy/src/deploy.ts
+++ b/releasing/plugin-commands-deploy/src/deploy.ts
@@ -109,5 +109,5 @@ export async function handler (
 async function copyProject (src: string, dest: string, opts: { includeOnlyPackageFiles: boolean }) {
  const { filesIndex } = await fetchFromDir(src, opts)
  const importPkg = createIndexedPkgImporter('clone-or-copy')
-  await importPkg(dest, { filesMap: filesIndex, force: true, fromStore: true })
+  importPkg(dest, { filesMap: filesIndex, force: true, fromStore: true })
 }
--- a/store/cafs-types/src/index.ts
+++ b/store/cafs-types/src/index.ts
@@ -37,6 +37,11 @@ export interface ImportPackageOpts {
 export type ImportPackageFunction = (
  to: string,
  opts: ImportPackageOpts
+) => { isBuilt: boolean, importMethod: undefined | string }
+
+export type ImportPackageFunctionAsync = (
+  to: string,
+  opts: ImportPackageOpts
 ) => Promise<{ isBuilt: boolean, importMethod: undefined | string }>

 export type FileType = 'exec' | 'nonexec' | 'index'
--- a/store/create-cafs-store/src/index.ts
+++ b/store/create-cafs-store/src/index.ts
@@ -9,7 +9,9 @@ import type { Cafs, PackageFilesResponse } from '@pnpm/cafs-types'
 import { createIndexedPkgImporter } from '@pnpm/fs.indexed-pkg-importer'
 import {
  type ImportIndexedPackage,
+  type ImportIndexedPackageAsync,
  type ImportPackageFunction,
+  type ImportPackageFunctionAsync,
  type PackageFileInfo,
 } from '@pnpm/store-controller-types'
 import memoize from 'mem'
@@ -18,6 +20,34 @@ import mapValues from 'ramda/src/map'

 export { type CafsLocker }

+export function createPackageImporterAsync (
+  opts: {
+    importIndexedPackage?: ImportIndexedPackageAsync
+    packageImportMethod?: 'auto' | 'hardlink' | 'copy' | 'clone' | 'clone-or-copy'
+    cafsDir: string
+  }
+): ImportPackageFunctionAsync {
+  const cachedImporterCreator = opts.importIndexedPackage
+    ? () => opts.importIndexedPackage!
+    : memoize(createIndexedPkgImporter)
+  const packageImportMethod = opts.packageImportMethod
+  const gfm = getFlatMap.bind(null, opts.cafsDir)
+  return async (to, opts) => {
+    const { filesMap, isBuilt } = gfm(opts.filesResponse, opts.sideEffectsCacheKey)
+    const pkgImportMethod = (opts.requiresBuild && !isBuilt)
+      ? 'clone-or-copy'
+      : (opts.filesResponse.packageImportMethod ?? packageImportMethod)
+    const impPkg = cachedImporterCreator(pkgImportMethod)
+    const importMethod = await impPkg(to, {
+      filesMap,
+      fromStore: opts.filesResponse.fromStore,
+      force: opts.force,
+      keepModulesDir: Boolean(opts.keepModulesDir),
+    })
+    return { importMethod, isBuilt }
+  }
+}
+
 function createPackageImporter (
  opts: {
    importIndexedPackage?: ImportIndexedPackage
@@ -30,13 +60,13 @@ function createPackageImporter (
    : memoize(createIndexedPkgImporter)
  const packageImportMethod = opts.packageImportMethod
  const gfm = getFlatMap.bind(null, opts.cafsDir)
-  return async (to, opts) => {
+  return (to, opts) => {
    const { filesMap, isBuilt } = gfm(opts.filesResponse, opts.sideEffectsCacheKey)
    const pkgImportMethod = (opts.requiresBuild && !isBuilt)
      ? 'clone-or-copy'
      : (opts.filesResponse.packageImportMethod ?? packageImportMethod)
    const impPkg = cachedImporterCreator(pkgImportMethod)
-    const importMethod = await impPkg(to, {
+    const importMethod = impPkg(to, {
      filesMap,
      fromStore: opts.filesResponse.fromStore,
      force: opts.force,
--- a/store/package-store/package.json
+++ b/store/package-store/package.json
@@ -16,7 +16,9 @@
  },
  "dependencies": {
    "@pnpm/create-cafs-store": "workspace:*",
+    "@pnpm/error": "workspace:*",
    "@pnpm/fetcher-base": "workspace:*",
+    "@pnpm/fetching.tarball-worker": "workspace:*",
    "@pnpm/package-requester": "workspace:*",
    "@pnpm/resolver-base": "workspace:*",
    "@pnpm/store-controller-types": "workspace:*",
--- a/store/package-store/src/storeController/index.ts
+++ b/store/package-store/src/storeController/index.ts
@@ -1,15 +1,17 @@
 import {
  type PackageFilesIndex,
 } from '@pnpm/store.cafs'
-import { createCafsStore, type CafsLocker } from '@pnpm/create-cafs-store'
+import { createCafsStore, createPackageImporterAsync, type CafsLocker } from '@pnpm/create-cafs-store'
 import { type Fetchers } from '@pnpm/fetcher-base'
+import { PnpmError } from '@pnpm/error'
 import { createPackageRequester } from '@pnpm/package-requester'
 import { type ResolveFunction } from '@pnpm/resolver-base'
 import {
-  type ImportIndexedPackage,
+  type ImportIndexedPackageAsync,
  type PackageFileInfo,
  type StoreController,
 } from '@pnpm/store-controller-types'
+import { workerPool as pool } from '@pnpm/fetching.tarball-worker'
 import loadJsonFile from 'load-json-file'
 import writeJsonFile from 'write-json-file'
 import { prune } from './prune'
@@ -24,7 +26,7 @@ export async function createPackageStore (
    engineStrict?: boolean
    force?: boolean
    nodeVersion?: string
-    importPackage?: ImportIndexedPackage
+    importPackage?: ImportIndexedPackageAsync
    pnpmVersion?: string
    ignoreFile?: (filename: string) => boolean
    cacheDir: string
@@ -35,8 +37,12 @@ export async function createPackageStore (
    verifyStoreIntegrity: boolean
  }
 ): Promise<StoreController> {
+  pool.reset()
  const storeDir = initOpts.storeDir
-  const cafs = createCafsStore(storeDir, initOpts)
+  const cafs = createCafsStore(storeDir, {
+    cafsLocker: initOpts.cafsLocker,
+    packageImportMethod: initOpts.packageImportMethod,
+  })
  const packageRequester = createPackageRequester({
    force: initOpts.force,
    engineStrict: initOpts.engineStrict,
@@ -59,7 +65,32 @@ export async function createPackageStore (
    },
    fetchPackage: packageRequester.fetchPackageToStore,
    getFilesIndexFilePath: packageRequester.getFilesIndexFilePath,
-    importPackage: cafs.importPackage,
+    importPackage: initOpts.importPackage
+      ? createPackageImporterAsync({ importIndexedPackage: initOpts.importPackage, cafsDir: cafs.cafsDir })
+      : async (targetDir, opts) => {
+        const localWorker = await pool.checkoutWorkerAsync(true)
+        return new Promise<{ isBuilt: boolean, importMethod: string | undefined }>((resolve, reject) => {
+          localWorker.once('message', ({ status, error, value }: any) => { // eslint-disable-line @typescript-eslint/no-explicit-any
+            pool.checkinWorker(localWorker)
+            if (status === 'error') {
+              reject(new PnpmError('LINKING_FAILED', error as string))
+              return
+            }
+            resolve(value)
+          })
+          localWorker.postMessage({
+            type: 'link',
+            filesResponse: opts.filesResponse,
+            packageImportMethod: initOpts.packageImportMethod,
+            sideEffectsCacheKey: opts.sideEffectsCacheKey,
+            storeDir: initOpts.storeDir,
+            targetDir,
+            requiresBuild: opts.requiresBuild,
+            force: opts.force,
+            keepModulesDir: opts.keepModulesDir,
+          })
+        })
+      },
    prune: prune.bind(null, { storeDir, cacheDir: initOpts.cacheDir }),
    requestPackage: packageRequester.requestPackage,
    upload,
--- a/store/package-store/tsconfig.json
+++ b/store/package-store/tsconfig.json
@@ -15,6 +15,12 @@
    {
      "path": "../../fetching/fetcher-base"
    },
+    {
+      "path": "../../fetching/tarball-worker"
+    },
+    {
+      "path": "../../packages/error"
+    },
    {
      "path": "../../packages/types"
    },
--- a/store/store-controller-types/src/index.ts
+++ b/store/store-controller-types/src/index.ts
@@ -7,6 +7,7 @@ import {
 } from '@pnpm/resolver-base'
 import type {
  ImportPackageFunction,
+  ImportPackageFunctionAsync,
  PackageFileInfo,
  PackageFilesResponse,
 } from '@pnpm/cafs-types'
@@ -15,7 +16,7 @@ import {
  type PackageManifest,
 } from '@pnpm/types'

-export type { PackageFileInfo, PackageFilesResponse, ImportPackageFunction }
+export type { PackageFileInfo, PackageFilesResponse, ImportPackageFunction, ImportPackageFunctionAsync }

 export * from '@pnpm/resolver-base'
 export type BundledManifest = Pick<
@@ -46,7 +47,7 @@ export interface StoreController {
  requestPackage: RequestPackageFunction
  fetchPackage: FetchPackageToStoreFunction
  getFilesIndexFilePath: GetFilesIndexFilePath
-  importPackage: ImportPackageFunction
+  importPackage: ImportPackageFunctionAsync
  close: () => Promise<void>
  prune: () => Promise<void>
  upload: UploadPkgToStore
@@ -158,4 +159,6 @@ export interface ImportOptions {
  keepModulesDir?: boolean
 }

-export type ImportIndexedPackage = (to: string, opts: ImportOptions) => Promise<string | undefined>
+export type ImportIndexedPackage = (to: string, opts: ImportOptions) => string | undefined
+
+export type ImportIndexedPackageAsync = (to: string, opts: ImportOptions) => Promise<string | undefined>