@pnpm/installing.deps-installer 1012.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,259 @@
+# @pnpm/core
+
+> Fast, disk space efficient installation engine. Used by [pnpm](https://github.com/pnpm/pnpm)
+
+## Install
+
+Install it via npm.
+
+```
+pnpm add @pnpm/core
+```
+
+It also depends on `@pnpm/logger` version `1`, so install it as well via:
+
+```
+pnpm add @pnpm/logger@1
+```
+
+## API
+
+### `mutateModules(importers, options)`
+
+TODO
+
+### `link(linkFromPkgs, linkToModules, [options])`
+
+Create symbolic links from the linked packages to the target package's `node_modules` (and its `node_modules/.bin`).
+
+**Arguments:**
+
+* `linkFromPkgs` - *String[]* - paths to the packages that should be linked.
+* `linkToModules` - *String* - path to the dependent package's `node_modules` directory.
+* `options.reporter` - *Function* - A function that listens for logs.
+
+### `linkToGlobal(linkFrom, options)`
+
+Create a symbolic link from the specified package to the global `node_modules`.
+
+**Arguments:**
+
+* `linkFrom` - *String* - path to the package that should be linked.
+* `globalDir` - *String* - path to the global directory.
+* `options.reporter` - *Function* - A function that listens for logs.
+
+### `linkFromGlobal(pkgNames, linkTo, options)`
+
+Create symbolic links from the global `pkgName`s to the `linkTo/node_modules` folder.
+
+**Arguments:**
+
+* `pkgNames` - *String[]* - packages to link.
+* `linkTo` - *String* - package to link to.
+* `globalDir` - *String* - path to the global directory.
+* `options.reporter` - *Function* - A function that listens for logs.
+
+### `storeStatus([options])`
+
+Return the list of modified dependencies.
+
+**Arguments:**
+
+* `options.reporter` - *Function* - A function that listens for logs.
+
+**Returns:** `Promise<string[]>` - the paths to the modified packages of the current project. The paths contain the location of packages in the store,
+not in the projects `node_modules` folder.
+
+### `storePrune([options])`
+
+Remove unreferenced packages from the store.
+
+## Hooks
+
+Hooks are functions that can step into the installation process. All hooks can be provided as arrays to register multiple hook functions.
+
+### `readPackage(pkg: Manifest, context): Manifest | Promise<Manifest>`
+
+This hook is called with every dependency's manifest information.
+The modified manifest returned by this hook is then used by `@pnpm/core` during installation.
+An async function is supported.
+
+**Arguments:**
+
+* `pkg` - The dependency's package manifest.
+* `context.log(message)` - A function to log debug messages.
+
+**Example:**
+
+```js
+const { installPkgs } = require('@pnpm/core')
+
+installPkgs({
+  hooks: {
+    readPackage: [readPackageHook]
+  }
+})
+
+function readPackageHook (pkg, context) {
+  if (pkg.name === 'foo') {
+    context.log('Modifying foo dependencies')
+    pkg.dependencies = {
+      bar: '^2.0.0',
+    }
+  }
+  return pkg
+}
+```
+
+### `preResolution(context, logger): Promise<void>`
+
+This hook is called after reading lockfiles but before resolving dependencies. It can modify lockfile objects.
+
+**Arguments:**
+
+* `context.wantedLockfile` - The lockfile from `pnpm-lock.yaml`.
+* `context.currentLockfile` - The lockfile from `node_modules/.pnpm/lock.yaml`.
+* `context.existsCurrentLockfile` - Boolean indicating if current lockfile exists.
+* `context.existsNonEmptyWantedLockfile` - Boolean indicating if wanted lockfile exists and is not empty.
+* `context.lockfileDir` - Directory containing the lockfile.
+* `context.storeDir` - Location of the store directory.
+* `context.registries` - Map of registry URLs.
+* `logger.info(message)` - Log an informational message.
+* `logger.warn(message)` - Log a warning message.
+
+### `afterAllResolved(lockfile: Lockfile): Lockfile | Promise<Lockfile>`
+
+This hook is called after all dependencies are resolved. It receives and returns the resolved lockfile object.
+An async function is supported.
+
+**Arguments:**
+
+* `lockfile` - The resolved lockfile object that will be written to `pnpm-lock.yaml`.
+
+### Custom Resolvers and Fetchers
+
+Custom resolvers and fetchers allow you to implement custom package resolution and fetching logic for new package identifier schemes (like `my-protocol:package-name`). These are defined as top-level exports in your `.pnpmfile.cjs`:
+
+* **Custom Resolvers**: Convert package descriptors (e.g., `foo@^1.0.0`) into resolutions
+* **Custom Fetchers**: Completely handle fetching for custom package types
+
+**Custom Resolver Interface:**
+
+```typescript
+interface CustomResolver {
+  // Resolution phase
+  canResolve?: (wantedDependency: WantedDependency) => boolean | Promise<boolean>
+  resolve?: (wantedDependency: WantedDependency, opts: ResolveOptions) => ResolveResult | Promise<ResolveResult>
+
+  // Force resolution check
+  shouldRefreshResolution?: (depPath: string, pkgSnapshot: PackageSnapshot) => boolean | Promise<boolean>
+}
+```
+
+**Custom Fetcher Interface:**
+
+```typescript
+interface CustomFetcher {
+  // Fetch phase - complete fetcher replacement
+  canFetch?: (pkgId: string, resolution: Resolution) => boolean | Promise<boolean>
+  fetch?: (cafs: Cafs, resolution: Resolution, opts: FetchOptions, fetchers: Fetchers) => FetchResult | Promise<FetchResult>
+}
+```
+
+**Custom Resolver Methods:**
+
+* `canResolve(wantedDependency)` - Returns `true` if this resolver can resolve the given package descriptor
+* `resolve(wantedDependency, opts)` - Resolves a package descriptor to a resolution. Should return an object with `id` and `resolution`
+* `shouldRefreshResolution(depPath, pkgSnapshot)` - Return `true` to trigger full resolution of all packages (skipping the "Lockfile is up to date" optimization). The `depPath` is the package identifier (e.g., `lodash@4.17.21`) and `pkgSnapshot` provides direct access to the lockfile entry (resolution, dependencies, etc.).
+
+**Custom Fetcher Methods:**
+
+* `canFetch(pkgId, resolution)` - Returns `true` if this fetcher can handle fetching for the given resolution
+* `fetch(cafs, resolution, opts, fetchers)` - Completely handles fetching the package contents. Receives the content-addressable file system (cafs), the resolution, fetch options, and pnpm's standard fetchers for delegation. Must return a FetchResult with the package files.
+
+**Example - Reusing pnpm's fetcher utilities:**
+
+```js
+// .pnpmfile.cjs
+const customResolver = {
+  canResolve: (wantedDependency) => {
+    return wantedDependency.alias.startsWith('company-cdn:')
+  },
+
+  resolve: async (wantedDependency, opts) => {
+    const actualName = wantedDependency.alias.replace('company-cdn:', '')
+    const version = await fetchVersionFromCompanyCDN(actualName, wantedDependency.bareSpecifier)
+
+    return {
+      id: `company-cdn:${actualName}@${version}`,
+      resolution: {
+        type: 'custom:cdn',
+        cdnUrl: `https://cdn.company.com/packages/${actualName}/${version}.tgz`,
+        cachedAt: Date.now(), // Custom metadata for shouldRefreshResolution
+      },
+    }
+  },
+
+  shouldRefreshResolution: (depPath, pkgSnapshot) => {
+    // Check custom metadata stored in the resolution
+    const cachedAt = pkgSnapshot.resolution?.cachedAt
+    if (cachedAt && Date.now() - cachedAt > 24 * 60 * 60 * 1000) {
+      return true // Re-resolve if cached more than 24 hours ago
+    }
+    return false
+  },
+}
+
+const customFetcher = {
+  canFetch: (pkgId, resolution) => {
+    return resolution.type === 'custom:cdn'
+  },
+
+  fetch: async (cafs, resolution, opts, fetchers) => {
+    // Delegate to pnpm's standard tarball fetcher
+    // Transform the custom resolution to a standard tarball resolution
+    const tarballResolution = {
+      tarball: resolution.cdnUrl,
+      integrity: resolution.integrity,
+    }
+
+    return fetchers.remoteTarball(cafs, tarballResolution, opts)
+  },
+}
+
+// Export as top-level arrays
+module.exports = {
+  resolvers: [customResolver],
+  fetchers: [customFetcher],
+}
+```
+
+**Delegating to Standard Fetchers:**
+
+The `fetchers` parameter passed to the custom fetcher's `fetch` method provides access to pnpm's standard fetchers for delegation:
+
+* `fetchers.remoteTarball` - Fetch from remote tarball URLs
+* `fetchers.localTarball` - Fetch from local tarball files
+* `fetchers.gitHostedTarball` - Fetch from GitHub/GitLab/Bitbucket tarballs
+* `fetchers.directory` - Fetch from local directories
+* `fetchers.git` - Fetch from git repositories
+
+See the test cases in `resolving/default-resolver/test/customResolver.ts` and `fetching/pick-fetcher/test/pickFetcher.ts` for complete working examples.
+
+**Notes:**
+
+* Multiple custom resolvers and fetchers can be registered; they are tried in order until one matches
+* All methods support both synchronous and asynchronous implementations
+* Custom resolvers are tried before pnpm's built-in resolvers (npm, git, tarball, etc.)
+* Custom fetchers can delegate to pnpm's standard fetchers via the `fetchers` parameter to avoid reimplementing common fetch logic
+* The `shouldRefreshResolution` hook allows fine-grained control over when packages should be re-resolved
+
+**Performance Considerations:**
+
+* `canResolve()` should be a cheap check (ideally synchronous) as it's called for every dependency during resolution
+* `resolve()` can be an expensive async operation (e.g., network requests) as it's only called for matching dependencies
+* If your `canResolve()` implementation is expensive, performance may be impacted during large installations
+
+## License
+
+[MIT](LICENSE)

package/lib/api.d.ts

@@ -0,0 +1,3 @@
+export * from './getPeerDependencyIssues.js';
+export * from './install/index.js';
+export { PeerDependencyIssuesError } from './install/reportPeerDependencyIssues.js';

package/lib/api.js

@@ -0,0 +1,4 @@
+export * from './getPeerDependencyIssues.js';
+export * from './install/index.js';
+export { PeerDependencyIssuesError } from './install/reportPeerDependencyIssues.js';
+//# sourceMappingURL=api.js.map

package/lib/getPeerDependencyIssues.d.ts

@@ -0,0 +1,5 @@
+import { type GetContextOptions, type ProjectOptions } from '@pnpm/installing.context';
+import type { PeerDependencyIssuesByProjects } from '@pnpm/types';
+import type { InstallOptions } from './install/extendInstallOptions.js';
+export type ListMissingPeersOptions = Partial<GetContextOptions> & Pick<InstallOptions, 'hooks' | 'catalogs' | 'dedupePeerDependents' | 'ignoreCompatibilityDb' | 'linkWorkspacePackagesDepth' | 'nodeVersion' | 'nodeLinker' | 'overrides' | 'packageExtensions' | 'ignoredOptionalDependencies' | 'preferWorkspacePackages' | 'saveWorkspaceProtocol' | 'storeController' | 'useGitBranchLockfile' | 'peersSuffixMaxLength'> & Partial<Pick<InstallOptions, 'supportedArchitectures'>> & Pick<GetContextOptions, 'autoInstallPeers' | 'excludeLinksFromLockfile' | 'storeDir'> & Required<Pick<InstallOptions, 'globalVirtualStoreDir' | 'virtualStoreDirMaxLength' | 'peersSuffixMaxLength'>>;
+export declare function getPeerDependencyIssues(projects: ProjectOptions[], opts: ListMissingPeersOptions): Promise<PeerDependencyIssuesByProjects>;

package/lib/getPeerDependencyIssues.js

@@ -0,0 +1,70 @@
+import { DEFAULT_REGISTRIES } from '@pnpm/config.normalize-registries';
+import { parseOverrides } from '@pnpm/config.parse-overrides';
+import { createReadPackageHook } from '@pnpm/hooks.read-package-hook';
+import { getContext } from '@pnpm/installing.context';
+import { getWantedDependencies, resolveDependencies } from '@pnpm/installing.deps-resolver';
+import { getPreferredVersionsFromLockfileAndManifests } from '@pnpm/lockfile.preferred-versions';
+export async function getPeerDependencyIssues(projects, opts) {
+    const lockfileDir = opts.lockfileDir ?? process.cwd();
+    const ctx = await getContext({
+        force: false,
+        extraBinPaths: [],
+        lockfileDir,
+        nodeLinker: opts.nodeLinker ?? 'isolated',
+        registries: DEFAULT_REGISTRIES,
+        useLockfile: true,
+        allProjects: projects,
+        ...opts,
+    });
+    const projectsToResolve = Object.values(ctx.projects).map((project) => ({
+        ...project,
+        updatePackageManifest: false,
+        wantedDependencies: getWantedDependencies(project.manifest, opts),
+    }));
+    const preferredVersions = getPreferredVersionsFromLockfileAndManifests(ctx.wantedLockfile.packages, Object.values(ctx.projects).map(({ manifest }) => manifest));
+    const overrides = parseOverrides(opts.overrides ?? {}, opts.catalogs ?? {});
+    const { peerDependencyIssuesByProjects, waitTillAllFetchingsFinish, } = await resolveDependencies(projectsToResolve, {
+        currentLockfile: ctx.currentLockfile,
+        allowedDeprecatedVersions: {},
+        allowUnusedPatches: false,
+        catalogs: opts.catalogs,
+        defaultUpdateDepth: -1,
+        dedupePeerDependents: opts.dedupePeerDependents,
+        dryRun: true,
+        engineStrict: false,
+        force: false,
+        forceFullResolution: true,
+        hooks: {
+            readPackage: createReadPackageHook({
+                ignoreCompatibilityDb: opts.ignoreCompatibilityDb,
+                lockfileDir,
+                overrides,
+                packageExtensions: opts.packageExtensions,
+                readPackageHook: opts.hooks?.readPackage,
+                ignoredOptionalDependencies: opts.ignoredOptionalDependencies,
+            }),
+        },
+        linkWorkspacePackagesDepth: opts.linkWorkspacePackagesDepth ?? (opts.saveWorkspaceProtocol ? 0 : -1),
+        lockfileDir,
+        nodeVersion: opts.nodeVersion ?? process.version,
+        pnpmVersion: '',
+        preferWorkspacePackages: opts.preferWorkspacePackages,
+        preferredVersions,
+        preserveWorkspaceProtocol: false,
+        registries: ctx.registries,
+        saveWorkspaceProtocol: false, // this doesn't matter in our case. We won't write changes to package.json files
+        storeController: opts.storeController,
+        tag: 'latest',
+        globalVirtualStoreDir: opts.globalVirtualStoreDir,
+        virtualStoreDir: ctx.virtualStoreDir,
+        virtualStoreDirMaxLength: ctx.virtualStoreDirMaxLength,
+        wantedLockfile: ctx.wantedLockfile,
+        workspacePackages: ctx.workspacePackages ?? new Map(),
+        supportedArchitectures: opts.supportedArchitectures,
+        peersSuffixMaxLength: opts.peersSuffixMaxLength,
+        allProjectIds: Object.values(ctx.projects).map((p) => p.id),
+    });
+    await waitTillAllFetchingsFinish();
+    return peerDependencyIssuesByProjects;
+}
+//# sourceMappingURL=getPeerDependencyIssues.js.map

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './api.js';
+export { UnexpectedStoreError } from './install/checkCompatibility/UnexpectedStoreError.js';
+export { UnexpectedVirtualStoreDirError } from './install/checkCompatibility/UnexpectedVirtualStoreDirError.js';
+export type { InstallOptions } from './install/extendInstallOptions.js';
+export { type ProjectOptions } from '@pnpm/installing.context';
+export type { UpdateMatchingFunction } from '@pnpm/installing.deps-resolver';
+export type { HoistingLimits } from '@pnpm/installing.deps-restorer';
+export type { WorkspacePackages } from '@pnpm/resolving.resolver-base';
+export type { BadPeerDependencyIssue, MissingPeerDependencyIssue, MissingPeerIssuesByPeerName, PackageManifest, PeerDependencyIssues, PeerDependencyIssuesByProjects, } from '@pnpm/types';

package/lib/index.js

@@ -0,0 +1,5 @@
+export * from './api.js';
+export { UnexpectedStoreError } from './install/checkCompatibility/UnexpectedStoreError.js';
+export { UnexpectedVirtualStoreDirError } from './install/checkCompatibility/UnexpectedVirtualStoreDirError.js';
+export {} from '@pnpm/installing.context';
+//# sourceMappingURL=index.js.map

package/lib/install/checkCompatibility/BreakingChangeError.d.ts

@@ -0,0 +1,12 @@
+import { PnpmError } from '@pnpm/error';
+import type { ErrorRelatedSources } from './ErrorRelatedSources.js';
+export interface BreakingChangeErrorOptions extends ErrorRelatedSources {
+    code: string;
+    message: string;
+}
+export declare class BreakingChangeError extends PnpmError {
+    relatedIssue?: number;
+    relatedPR?: number;
+    additionalInformation?: string;
+    constructor(opts: BreakingChangeErrorOptions);
+}

package/lib/install/checkCompatibility/BreakingChangeError.js

@@ -0,0 +1,13 @@
+import { PnpmError } from '@pnpm/error';
+export class BreakingChangeError extends PnpmError {
+    relatedIssue;
+    relatedPR;
+    additionalInformation;
+    constructor(opts) {
+        super(opts.code, opts.message);
+        this.relatedIssue = opts.relatedIssue;
+        this.relatedPR = opts.relatedPR;
+        this.additionalInformation = opts.additionalInformation;
+    }
+}
+//# sourceMappingURL=BreakingChangeError.js.map

package/lib/install/checkCompatibility/CatalogVersionMismatchError.d.ts

@@ -0,0 +1,9 @@
+import { PnpmError } from '@pnpm/error';
+export declare class CatalogVersionMismatchError extends PnpmError {
+    catalogDep: string;
+    wantedDep: string;
+    constructor(opts: {
+        catalogDep: string;
+        wantedDep: string;
+    });
+}

package/lib/install/checkCompatibility/CatalogVersionMismatchError.js

@@ -0,0 +1,11 @@
+import { PnpmError } from '@pnpm/error';
+export class CatalogVersionMismatchError extends PnpmError {
+    catalogDep;
+    wantedDep;
+    constructor(opts) {
+        super('CATALOG_VERSION_MISMATCH', 'Wanted dependency outside the version range defined in catalog');
+        this.catalogDep = opts.catalogDep;
+        this.wantedDep = opts.wantedDep;
+    }
+}
+//# sourceMappingURL=CatalogVersionMismatchError.js.map

package/lib/install/checkCompatibility/ErrorRelatedSources.d.ts

@@ -0,0 +1,5 @@
+export interface ErrorRelatedSources {
+    additionalInformation?: string;
+    relatedIssue?: number;
+    relatedPR?: number;
+}

package/lib/install/checkCompatibility/ErrorRelatedSources.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ErrorRelatedSources.js.map

package/lib/install/checkCompatibility/ModulesBreakingChangeError.d.ts

@@ -0,0 +1,9 @@
+import { BreakingChangeError } from './BreakingChangeError.js';
+import type { ErrorRelatedSources } from './ErrorRelatedSources.js';
+export interface ModulesBreakingChangeErrorOptions extends ErrorRelatedSources {
+    modulesPath: string;
+}
+export declare class ModulesBreakingChangeError extends BreakingChangeError {
+    modulesPath: string;
+    constructor(opts: ModulesBreakingChangeErrorOptions);
+}

package/lib/install/checkCompatibility/ModulesBreakingChangeError.js

@@ -0,0 +1,15 @@
+import { BreakingChangeError } from './BreakingChangeError.js';
+export class ModulesBreakingChangeError extends BreakingChangeError {
+    modulesPath;
+    constructor(opts) {
+        super({
+            additionalInformation: opts.additionalInformation,
+            code: 'MODULES_BREAKING_CHANGE',
+            message: `The node_modules structure at "${opts.modulesPath}" is not compatible with the current pnpm version. Run "pnpm install --force" to recreate node_modules.`,
+            relatedIssue: opts.relatedIssue,
+            relatedPR: opts.relatedPR,
+        });
+        this.modulesPath = opts.modulesPath;
+    }
+}
+//# sourceMappingURL=ModulesBreakingChangeError.js.map

package/lib/install/checkCompatibility/UnexpectedStoreError.d.ts

@@ -0,0 +1,11 @@
+import { PnpmError } from '@pnpm/error';
+export declare class UnexpectedStoreError extends PnpmError {
+    expectedStorePath: string;
+    actualStorePath: string;
+    modulesDir: string;
+    constructor(opts: {
+        expectedStorePath: string;
+        actualStorePath: string;
+        modulesDir: string;
+    });
+}

package/lib/install/checkCompatibility/UnexpectedStoreError.js

@@ -0,0 +1,13 @@
+import { PnpmError } from '@pnpm/error';
+export class UnexpectedStoreError extends PnpmError {
+    expectedStorePath;
+    actualStorePath;
+    modulesDir;
+    constructor(opts) {
+        super('UNEXPECTED_STORE', 'Unexpected store location');
+        this.expectedStorePath = opts.expectedStorePath;
+        this.actualStorePath = opts.actualStorePath;
+        this.modulesDir = opts.modulesDir;
+    }
+}
+//# sourceMappingURL=UnexpectedStoreError.js.map

package/lib/install/checkCompatibility/UnexpectedVirtualStoreDirError.d.ts

@@ -0,0 +1,11 @@
+import { PnpmError } from '@pnpm/error';
+export declare class UnexpectedVirtualStoreDirError extends PnpmError {
+    expected: string;
+    actual: string;
+    modulesDir: string;
+    constructor(opts: {
+        expected: string;
+        actual: string;
+        modulesDir: string;
+    });
+}

package/lib/install/checkCompatibility/UnexpectedVirtualStoreDirError.js

@@ -0,0 +1,13 @@
+import { PnpmError } from '@pnpm/error';
+export class UnexpectedVirtualStoreDirError extends PnpmError {
+    expected;
+    actual;
+    modulesDir;
+    constructor(opts) {
+        super('UNEXPECTED_VIRTUAL_STORE', 'Unexpected virtual store location');
+        this.expected = opts.expected;
+        this.actual = opts.actual;
+        this.modulesDir = opts.modulesDir;
+    }
+}
+//# sourceMappingURL=UnexpectedVirtualStoreDirError.js.map

package/lib/install/checkCompatibility/index.d.ts

@@ -0,0 +1,6 @@
+import type { Modules } from '@pnpm/installing.modules-yaml';
+export declare function checkCompatibility(modules: Modules, opts: {
+    storeDir: string;
+    modulesDir: string;
+    virtualStoreDir: string;
+}): void;

package/lib/install/checkCompatibility/index.js

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { LAYOUT_VERSION } from '@pnpm/constants';
+import { ModulesBreakingChangeError } from './ModulesBreakingChangeError.js';
+import { UnexpectedStoreError } from './UnexpectedStoreError.js';
+import { UnexpectedVirtualStoreDirError } from './UnexpectedVirtualStoreDirError.js';
+export function checkCompatibility(modules, opts) {
+    if (!modules.layoutVersion || modules.layoutVersion !== LAYOUT_VERSION) {
+        throw new ModulesBreakingChangeError({
+            modulesPath: opts.modulesDir,
+        });
+    }
+    // Important: comparing paths with path.relative()
+    // is the only way to compare paths correctly on Windows
+    // as of Node.js 4-9
+    // See related issue: https://github.com/pnpm/pnpm/issues/996
+    if (!modules.storeDir ||
+        path.relative(modules.storeDir, opts.storeDir) !== '' && path.relative(modules.storeDir, path.join(opts.storeDir, '../v3')) !== '') {
+        throw new UnexpectedStoreError({
+            actualStorePath: opts.storeDir,
+            expectedStorePath: modules.storeDir,
+            modulesDir: opts.modulesDir,
+        });
+    }
+    if (modules.virtualStoreDir && path.relative(modules.virtualStoreDir, opts.virtualStoreDir) !== '') {
+        throw new UnexpectedVirtualStoreDirError({
+            actual: opts.virtualStoreDir,
+            expected: modules.virtualStoreDir,
+            modulesDir: opts.modulesDir,
+        });
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/install/checkCustomResolverForceResolve.d.ts

@@ -0,0 +1,10 @@
+import type { CustomResolver } from '@pnpm/hooks.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+/**
+ * Check if any custom resolver's shouldRefreshResolution returns true for any
+ * package in the lockfile. shouldRefreshResolution is called independently of
+ * canResolve — it runs before resolution, so the original specifier is not
+ * available. Each resolver's shouldRefreshResolution is responsible for its own
+ * filtering logic.
+ */
+export declare function checkCustomResolverForceResolve(customResolvers: CustomResolver[], wantedLockfile: LockfileObject): Promise<boolean>;

package/lib/install/checkCustomResolverForceResolve.js

@@ -0,0 +1,47 @@
+/**
+ * Check if any custom resolver's shouldRefreshResolution returns true for any
+ * package in the lockfile. shouldRefreshResolution is called independently of
+ * canResolve — it runs before resolution, so the original specifier is not
+ * available. Each resolver's shouldRefreshResolution is responsible for its own
+ * filtering logic.
+ */
+export async function checkCustomResolverForceResolve(customResolvers, wantedLockfile) {
+    if (!wantedLockfile.packages)
+        return false;
+    const hooks = [];
+    for (const resolver of customResolvers) {
+        if (resolver.shouldRefreshResolution)
+            hooks.push(resolver.shouldRefreshResolution);
+    }
+    if (hooks.length === 0)
+        return false;
+    const asyncChecks = [];
+    for (const [depPath, pkgSnapshot] of Object.entries(wantedLockfile.packages)) {
+        for (const hook of hooks) {
+            const result = hook(depPath, pkgSnapshot);
+            if (result === true)
+                return true;
+            if (result !== false)
+                asyncChecks.push(result);
+        }
+    }
+    if (asyncChecks.length === 0)
+        return false;
+    return anyTrue(asyncChecks);
+}
+async function anyTrue(promises) {
+    return new Promise((resolve, reject) => {
+        let remaining = promises.length;
+        if (remaining === 0)
+            return resolve(false);
+        for (const p of promises) {
+            p.then(value => {
+                if (value)
+                    resolve(true);
+                else if (--remaining === 0)
+                    resolve(false);
+            }, reject);
+        }
+    });
+}
+//# sourceMappingURL=checkCustomResolverForceResolve.js.map