pnpm
diff --git a/‎config/deps-installer/test/resolveConfigDeps.test.ts‎
Lines changed: 1 addition & 0 deletions b/‎config/deps-installer/test/resolveConfigDeps.test.ts‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎env/node.resolver/src/index.ts‎
Lines changed: 12 additions & 1 deletion b/‎env/node.resolver/src/index.ts‎
Lines changed: 12 additions & 1 deletion
diff --git a/‎pkg-manager/client/test/index.ts‎
Lines changed: 2 additions & 0 deletions b/‎pkg-manager/client/test/index.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎pkg-manager/package-requester/src/packageRequester.ts‎
Lines changed: 45 additions & 169 deletions b/‎pkg-manager/package-requester/src/packageRequester.ts‎
Lines changed: 45 additions & 169 deletions
@@ -19,6 +19,7 @@ test('configuration dependency is resolved', async () => {
     cacheDir: path.resolve('cache'),
     userConfig: {},
     store: storeController,
+    storeDir: '.store',
   })
 
   const workspaceManifest = readYamlFile<{ configDependencies: Record<string, string> }>('pnpm-workspace.yaml')
 
@@ -5,6 +5,7 @@ import { type FetchFromRegistry } from '@pnpm/fetching-types'
 import {
   type BinaryResolution,
   type PlatformAssetResolution,
+  type ResolveOptions,
   type ResolveResult,
   type VariationsResolution,
   type WantedDependency,
@@ -29,9 +30,19 @@ export async function resolveNodeRuntime (
     rawConfig: Record<string, string>
     offline?: boolean
   },
-  wantedDependency: WantedDependency
+  wantedDependency: WantedDependency,
+  opts?: Partial<ResolveOptions>
 ): Promise<NodeRuntimeResolveResult | null> {
   if (wantedDependency.alias !== 'node' || !wantedDependency.bareSpecifier?.startsWith('runtime:')) return null
+
+  if (opts?.currentPkg && !opts.update) {
+    return {
+      id: opts.currentPkg.id,
+      resolution: opts.currentPkg.resolution as VariationsResolution,
+      resolvedVia: 'nodejs.org',
+    }
+  }
+
   if (ctx.offline) throw new PnpmError('NO_OFFLINE_NODEJS_RESOLUTION', 'Offline Node.js resolution is not supported')
   const versionSpec = wantedDependency.bareSpecifier.substring('runtime:'.length)
   const { releaseChannel, versionSpecifier } = parseEnvSpecifier(versionSpec)
 
@@ -9,6 +9,7 @@ test('createClient()', () => {
     registries: {
       default: 'https://reigstry.npmjs.org/',
     },
+    storeDir: '.store',
   })
   expect(typeof client === 'object').toBeTruthy()
 })
@@ -21,6 +22,7 @@ test('createResolver()', () => {
     registries: {
       default: 'https://reigstry.npmjs.org/',
     },
+    storeDir: '.store',
   })
   expect(typeof resolve === 'function').toBeTruthy()
 })
@@ -12,7 +12,7 @@ import {
   type FetchOptions,
   type FetchResult,
 } from '@pnpm/fetcher-base'
-import { type Cafs, type PackageFilesResponse } from '@pnpm/cafs-types'
+import { type Cafs } from '@pnpm/cafs-types'
 import gfs from '@pnpm/graceful-fs'
 import { logger } from '@pnpm/logger'
 import { packageIsInstallable } from '@pnpm/package-is-installable'
@@ -139,18 +139,12 @@ export function createPackageRequester (
     virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
     strictStorePkgContentCheck: opts.strictStorePkgContentCheck,
   })
-  const peekPackageFromStore = peekFromStore.bind(null, {
-    getIndexFilePathInCafs,
-    readPkgFromCafs,
-    fetchingLockerForPeek: new Map(),
-  })
   const requestPackage = resolveAndFetch.bind(null, {
     engineStrict: opts.engineStrict,
     nodeVersion: opts.nodeVersion,
     pnpmVersion: opts.pnpmVersion,
     force: opts.force,
     fetchPackageToStore,
-    peekPackageFromStore,
     requestsQueue,
     resolve: opts.resolve,
     storeDir: opts.storeDir,
@@ -176,113 +170,57 @@ async function resolveAndFetch (
     requestsQueue: { add: <T>(fn: () => Promise<T>, opts: { priority: number }) => Promise<T> }
     resolve: ResolveFunction
     fetchPackageToStore: FetchPackageToStoreFunction
-    peekPackageFromStore: (pkg: PkgNameVersion & {
-      id: string
-      resolution: Resolution
-    }) => Promise<PeekFromStoreResult | undefined>
     storeDir: string
   },
   wantedDependency: WantedDependency & { optional?: boolean },
   options: RequestPackageOptions
 ): Promise<PackageResponse> {
-  let latest: string | undefined
-  let manifest: DependencyManifest | undefined
-  let normalizedBareSpecifier: string | undefined
-  let alias: string | undefined
   let resolution = options.currentPkg?.resolution as Resolution
   let pkgId = options.currentPkg?.id
-  const skipResolution = resolution && !options.update
-  let forceFetch = false
-  let updated = false
-  let resolvedVia: string | undefined
-  let publishedAt: string | undefined
-
-  async function performResolution () {
-    // When skipResolution is set but a resolution is still performed due to
-    // options.skipFetch, it's necessary to make sure the resolution doesn't
-    // accidentally return a newer version of the package. When skipFetch is
-    // set, the resolved package shouldn't be different. This is done by
-    // overriding the preferredVersions object to only contain the current
-    // package's version.
-    //
-    // A naive approach would be to change the bare specifier to be the exact
-    // version of the current pkg if the bare specifier is a range, but this
-    // would cause the version returned for calcSpecifier to be different.
-    const preferredVersions: PreferredVersions = (skipResolution && options.currentPkg?.name != null && options.currentPkg?.version != null)
-      ? {
-        ...options.preferredVersions,
-        [options.currentPkg.name]: { [options.currentPkg.version]: 'version' },
-      }
-      : options.preferredVersions
-
-    const resolveResult = await ctx.requestsQueue.add<ResolveResult>(async () => ctx.resolve(wantedDependency, {
-      alwaysTryWorkspacePackages: options.alwaysTryWorkspacePackages,
-      defaultTag: options.defaultTag,
-      trustPolicy: options.trustPolicy,
-      trustPolicyExclude: options.trustPolicyExclude,
-      trustPolicyIgnoreAfter: options.trustPolicyIgnoreAfter,
-      publishedBy: options.publishedBy,
-      publishedByExclude: options.publishedByExclude,
-      pickLowestVersion: options.pickLowestVersion,
-      lockfileDir: options.lockfileDir,
-      preferredVersions,
-      preferWorkspacePackages: options.preferWorkspacePackages,
-      projectDir: options.projectDir,
-      workspacePackages: options.workspacePackages,
-      update: options.update,
-      injectWorkspacePackages: options.injectWorkspacePackages,
-      calcSpecifier: options.calcSpecifier,
-      pinnedVersion: options.pinnedVersion,
-    }), { priority: options.downloadPriority })
-
-    manifest = resolveResult.manifest
-    latest = resolveResult.latest
-    resolvedVia = resolveResult.resolvedVia
-    publishedAt = resolveResult.publishedAt
-
-    // If the integrity of a local tarball dependency has changed,
-    // the local tarball should be unpacked, so a fetch to the store should be forced
-    forceFetch = Boolean(
-      ((options.currentPkg?.resolution) != null) &&
-      pkgId?.startsWith('file:') &&
-      (options.currentPkg?.resolution as TarballResolution).integrity !== (resolveResult.resolution as TarballResolution).integrity
-    )
-
-    updated = pkgId !== resolveResult.id || !resolution || forceFetch
-    resolution = resolveResult.resolution
-    pkgId = resolveResult.id
-    normalizedBareSpecifier = resolveResult.normalizedBareSpecifier
-    alias = resolveResult.alias
-  }
 
-  // When fetching is skipped, we still need the package's manifest for
-  // lockfile-only installs.
+  // When we have a currentPkg but a resolution is still performed due to
+  // options.skipFetch, it's necessary to make sure the resolution doesn't
+  // accidentally return a newer version of the package. When skipFetch is
+  // set, the resolved package shouldn't be different. This is done by
+  // overriding the preferredVersions object to only contain the current
+  // package's version.
   //
-  // The package manifest could be retrieved from CAFS if the package has been
-  // fetched previously. Otherwise we'll need to perform a resolution.
-  //
-  // The resolution step is never skipped for local dependencies.
-  if (!skipResolution || options.skipFetch === true || Boolean(pkgId?.startsWith('file:')) || wantedDependency.optional === true) {
-    // If the manifest for this package is in the store, retrieving it from the
-    // Content-Addressable File Store will be significantly faster than fetching
-    // it from metadata. This is because package metadata contains the
-    // package.json contents of a package across all of its versions, which
-    // takes a long time to parse.
-    if (skipResolution && !pkgId?.startsWith('file:') && wantedDependency.optional !== true && pkgId != null) {
-      const pkg = await ctx.peekPackageFromStore({
-        ...options.expectedPkg,
-        id: pkgId,
-        resolution,
-      })
-      manifest = pkg?.bundledManifest
+  // A naive approach would be to change the bare specifier to be the exact
+  // version of the current pkg if the bare specifier is a range, but this
+  // would cause the version returned for calcSpecifier to be different.
+  const preferredVersions: PreferredVersions = (resolution && !options.update && options.currentPkg?.name != null && options.currentPkg?.version != null)
+    ? {
+      ...options.preferredVersions,
+      [options.currentPkg.name]: { [options.currentPkg.version]: 'version' },
     }
+    : options.preferredVersions
 
-    // However, if the optimization above isn't possible or the package has
-    // never been added to the CAFS, we'll need to perform a resolution.
-    if (manifest == null) {
-      await performResolution()
-    }
-  }
+  const resolveResult = await ctx.requestsQueue.add<ResolveResult>(async () => ctx.resolve(wantedDependency, {
+    ...options,
+    preferredVersions,
+    currentPkg: (options.currentPkg?.id && options.currentPkg?.resolution)
+      ? {
+        id: options.currentPkg.id,
+        name: options.currentPkg.name,
+        version: options.currentPkg.version,
+        resolution: options.currentPkg.resolution,
+      }
+      : undefined,
+  }), { priority: options.downloadPriority })
+
+  let { manifest } = resolveResult
+  const {
+    latest,
+    resolvedVia,
+    publishedAt,
+    normalizedBareSpecifier,
+    alias,
+    forceFetch,
+  } = resolveResult
+
+  const updated = pkgId !== resolveResult.id || !resolution || forceFetch === true
+  resolution = resolveResult.resolution
+  pkgId = resolveResult.id
 
   const id = pkgId!
 
@@ -319,8 +257,9 @@ async function resolveAndFetch (
     )
   )
   // We can skip fetching the package only if the manifest
-  // is present after resolution
-  if ((options.skipFetch === true || isInstallable === false) && (manifest != null)) {
+  // is present after resolution AND we're not forcing a fetch
+  // (forceFetch is set by resolvers when package content may have changed)
+  if ((options.skipFetch === true || isInstallable === false) && !forceFetch && (manifest != null)) {
     return {
       body: {
         id,
@@ -342,7 +281,7 @@ async function resolveAndFetch (
   const fetchResult = ctx.fetchPackageToStore({
     allowBuild: options.allowBuild,
     fetchRawManifest: true,
-    force: forceFetch,
+    force: forceFetch === true,
     ignoreScripts: options.ignoreScripts,
     lockfileDir: options.lockfileDir,
     pkg: {
@@ -673,69 +612,6 @@ function fetchToStore (
   }
 }
 
-interface PeekFromStoreResult {
-  readonly bundledManifest?: BundledManifest
-  readonly files: PackageFilesResponse
-}
-
-/**
- * Look up requests from the store without mutating it. This is related to
- * {@link fetchToStore}, but does not perform a fetch if the lookup was not
- * found.
- *
- * This function will return undefined if the package was found in the store,
- * but fails integrity checks.
- */
-async function peekFromStore (
-  ctx: {
-    readPkgFromCafs: (
-      filesIndexFile: string,
-      opts?: ReadPkgFromCafsOptions
-    ) => Promise<ReadPkgFromCafsResult>
-    getIndexFilePathInCafs: (integrity: string, pkgId: string) => string
-    fetchingLockerForPeek: Map<string, Promise<PeekFromStoreResult | undefined>>
-  },
-  pkg: PkgNameVersion & {
-    id: string
-    resolution: Resolution
-  }
-): Promise<PeekFromStoreResult | undefined> {
-  // This function only supports TarballResolution requests with a present
-  // integrity.
-  if (pkg.resolution.type != null || pkg.resolution.integrity == null) {
-    return undefined
-  }
-
-  const indexFilePathInCafs = ctx.getIndexFilePathInCafs(pkg.resolution.integrity, pkg.id)
-  const existingRequest = ctx.fetchingLockerForPeek.get(indexFilePathInCafs)
-
-  if (existingRequest != null) {
-    return existingRequest
-  }
-
-  const request = ctx.readPkgFromCafs(indexFilePathInCafs, {
-    readManifest: true,
-    expectedPkg: pkg,
-  })
-    .then(({ files, manifest, verified }): PeekFromStoreResult | undefined => {
-      // If the files in the store are corrupted or out of date, it's better to
-      // fail the peek result and allow the caller to fall back to a resolution
-      // or proper fetch.
-      if (!verified) {
-        return undefined
-      }
-
-      return {
-        files,
-        bundledManifest: manifest == null ? manifest : normalizeBundledManifest(manifest),
-      }
-    })
-
-  ctx.fetchingLockerForPeek.set(indexFilePathInCafs, request)
-
-  return request
-}
-
 async function readBundledManifest (pkgJsonPath: string): Promise<BundledManifest> {
   return pickBundledManifest(await readPackageJson(pkgJsonPath) as DependencyManifest)
 }