@pnpm/deps.graph-hasher 1100.0.0 → 1100.1.0

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import type { LockfileObject, LockfileResolution, PackageSnapshot } from '@pnpm/lockfile.types';
-import type { AllowBuild, DepPath, PkgIdWithPatchHash } from '@pnpm/types';
+import type { AllowBuild, DepPath, PkgIdWithPatchHash, SupportedArchitectures } from '@pnpm/types';
 export type DepsGraph<T extends string> = Record<T, DepsGraphNode<T>>;
 export interface DepsGraphNode<T extends string> {
     children: {
@@ -15,6 +15,7 @@ export interface DepsStateCache {
 export declare function calcDepState<T extends string>(depsGraph: DepsGraph<T>, cache: DepsStateCache, depPath: string, opts: {
     patchFileHash?: string;
     includeDepGraphHash: boolean;
+    supportedArchitectures?: SupportedArchitectures;
 }): string;
 export interface PkgMeta {
     depPath: DepPath;
@@ -26,12 +27,13 @@ export interface HashedDepPath<T extends PkgMeta> {
     pkgMeta: T;
     hash: string;
 }
-export declare function iterateHashedGraphNodes<T extends PkgMeta>(graph: DepsGraph<DepPath>, pkgMetaIterator: PkgMetaIterator<T>, allowBuild?: AllowBuild): IterableIterator<HashedDepPath<T>>;
-export declare function calcGraphNodeHash<T extends PkgMeta>({ graph, cache, builtDepPaths, buildRequiredCache }: {
+export declare function iterateHashedGraphNodes<T extends PkgMeta>(graph: DepsGraph<DepPath>, pkgMetaIterator: PkgMetaIterator<T>, allowBuild?: AllowBuild, supportedArchitectures?: SupportedArchitectures): IterableIterator<HashedDepPath<T>>;
+export declare function calcGraphNodeHash<T extends PkgMeta>({ graph, cache, builtDepPaths, buildRequiredCache, supportedArchitectures }: {
     graph: DepsGraph<DepPath>;
     cache: DepsStateCache;
     builtDepPaths?: Set<DepPath>;
     buildRequiredCache?: Record<string, boolean>;
+    supportedArchitectures?: SupportedArchitectures;
 }, pkgMeta: T): string;
 export declare function calcLeafGlobalVirtualStorePath(fullPkgId: string, name: string, version: string): string;
 export interface PkgMetaAndSnapshot extends PkgMeta {
@@ -39,4 +41,4 @@ export interface PkgMetaAndSnapshot extends PkgMeta {
     pkgIdWithPatchHash: PkgIdWithPatchHash;
 }
 export declare function iteratePkgMeta(lockfile: LockfileObject, graph: DepsGraph<DepPath>): PkgMetaIterator<PkgMetaAndSnapshot>;
-export declare function lockfileToDepGraph(lockfile: LockfileObject): DepsGraph<DepPath>;
+export declare function lockfileToDepGraph(lockfile: LockfileObject, supportedArchitectures?: SupportedArchitectures): DepsGraph<DepPath>;

package/lib/index.js

@@ -2,10 +2,12 @@ import { ENGINE_NAME } from '@pnpm/constants';
 import { hashObject, hashObjectWithoutSorting } from '@pnpm/crypto.object-hasher';
 import { getPkgIdWithPatchHash, refToRelative } from '@pnpm/deps.path';
 import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
+import { resolvePlatformSelector, selectPlatformVariant } from '@pnpm/resolving.resolver-base';
+import { familySync } from 'detect-libc';
 export function calcDepState(depsGraph, cache, depPath, opts) {
     let result = ENGINE_NAME;
     if (opts.includeDepGraphHash) {
-        const depGraphHash = calcDepGraphHash(depsGraph, cache, new Set(), depPath);
+        const depGraphHash = calcDepGraphHash(depsGraph, cache, new Set(), depPath, opts.supportedArchitectures);
         result += `;deps=${depGraphHash}`;
     }
     if (opts.patchFileHash) {
@@ -13,7 +15,7 @@ export function calcDepState(depsGraph, cache, depPath, opts) {
     }
     return result;
 }
-function calcDepGraphHash(depsGraph, cache, parents, depPath) {
+function calcDepGraphHash(depsGraph, cache, parents, depPath, supportedArchitectures) {
     if (cache[depPath])
         return cache[depPath];
     const node = depsGraph[depPath];
@@ -26,16 +28,15 @@ function calcDepGraphHash(depsGraph, cache, parents, depPath) {
         if (!node.resolution) {
             throw new Error(`resolution is not defined for ${depPath} in depsGraph`);
         }
-        node.fullPkgId = createFullPkgId(node.pkgIdWithPatchHash, node.resolution);
+        node.fullPkgId = createFullPkgId(node.pkgIdWithPatchHash, node.resolution, supportedArchitectures);
     }
     const deps = {};
     if (Object.keys(node.children).length && !parents.has(node.fullPkgId)) {
         const nextParents = new Set([...Array.from(parents), node.fullPkgId]);
-        const _calcDepGraphHash = calcDepGraphHash.bind(null, depsGraph, cache, nextParents);
         for (const alias in node.children) {
             if (Object.hasOwn(node.children, alias)) {
                 const childId = node.children[alias];
-                deps[alias] = _calcDepGraphHash(childId);
+                deps[alias] = calcDepGraphHash(depsGraph, cache, nextParents, childId, supportedArchitectures);
             }
         }
     }
@@ -45,7 +46,7 @@ function calcDepGraphHash(depsGraph, cache, parents, depPath) {
     });
     return cache[depPath];
 }
-export function* iterateHashedGraphNodes(graph, pkgMetaIterator, allowBuild) {
+export function* iterateHashedGraphNodes(graph, pkgMetaIterator, allowBuild, supportedArchitectures) {
     let builtDepPaths;
     let entries;
     if (allowBuild != null) {
@@ -56,20 +57,21 @@ export function* iterateHashedGraphNodes(graph, pkgMetaIterator, allowBuild) {
     else {
         entries = pkgMetaIterator;
     }
-    const _calcGraphNodeHash = calcGraphNodeHash.bind(null, {
+    const ctx = {
         graph,
         cache: {},
         builtDepPaths,
         buildRequiredCache: builtDepPaths !== undefined ? {} : undefined,
-    });
+        supportedArchitectures,
+    };
     for (const pkgMeta of entries) {
         yield {
-            hash: _calcGraphNodeHash(pkgMeta),
+            hash: calcGraphNodeHash(ctx, pkgMeta),
             pkgMeta,
         };
     }
 }
-export function calcGraphNodeHash({ graph, cache, builtDepPaths, buildRequiredCache }, pkgMeta) {
+export function calcGraphNodeHash({ graph, cache, builtDepPaths, buildRequiredCache, supportedArchitectures }, pkgMeta) {
     const { name, version, depPath } = pkgMeta;
     // When builtDepPaths is provided (derived from the allowBuilds config),
     // we only include the engine name for packages that are allowed to build
@@ -79,7 +81,7 @@ export function calcGraphNodeHash({ graph, cache, builtDepPaths, buildRequiredCa
     const includeEngine = builtDepPaths === undefined ||
         transitivelyRequiresBuild(graph, builtDepPaths, buildRequiredCache ??= {}, depPath, new Set());
     const engine = includeEngine ? ENGINE_NAME : null;
-    const deps = calcDepGraphHash(graph, cache, new Set(), depPath);
+    const deps = calcDepGraphHash(graph, cache, new Set(), depPath, supportedArchitectures);
     const hexDigest = hashObjectWithoutSorting({ engine, deps }, { encoding: 'hex' });
     return formatGlobalVirtualStorePath(name, version, hexDigest);
 }
@@ -114,7 +116,7 @@ export function* iteratePkgMeta(lockfile, graph) {
         };
     }
 }
-export function lockfileToDepGraph(lockfile) {
+export function lockfileToDepGraph(lockfile, supportedArchitectures) {
     const graph = {};
     if (lockfile.packages != null) {
         for (const [depPath, pkgSnapshot] of Object.entries(lockfile.packages)) {
@@ -124,7 +126,7 @@ export function lockfileToDepGraph(lockfile) {
             });
             graph[depPath] = {
                 children,
-                fullPkgId: createFullPkgId(getPkgIdWithPatchHash(depPath), pkgSnapshot.resolution),
+                fullPkgId: createFullPkgId(getPkgIdWithPatchHash(depPath), pkgSnapshot.resolution, supportedArchitectures),
             };
         }
     }
@@ -174,8 +176,30 @@ function lockfileDepsToGraphChildren(deps) {
     }
     return children;
 }
-function createFullPkgId(pkgIdWithPatchHash, resolution) {
-    const res = 'integrity' in resolution ? String(resolution.integrity) : hashObject(resolution);
-    return `${pkgIdWithPatchHash}:${res}`;
+function createFullPkgId(pkgIdWithPatchHash, resolution, supportedArchitectures) {
+    if ('integrity' in resolution && resolution.integrity != null) {
+        return `${pkgIdWithPatchHash}:${resolution.integrity}`;
+    }
+    if ('type' in resolution && resolution.type === 'variations') {
+        // Variations resolutions list every platform variant for a runtime (e.g. all
+        // OS/arch combinations for a Node.js version). Hashing the whole object
+        // would be identical across hosts, so two projects that install different
+        // variants of the same runtime would collide on the same virtual store
+        // directory — the first install would "win" and subsequent installs with
+        // different --os/--cpu/--libc would silently reuse the cached variant.
+        // Incorporate the chosen variant's integrity instead so each variant gets
+        // its own entry in the global virtual store.
+        const selector = resolvePlatformSelector(supportedArchitectures, {
+            platform: process.platform,
+            arch: process.arch,
+            libc: familySync(),
+        });
+        const variant = selectPlatformVariant(resolution.variants, selector);
+        const chosenResolution = variant?.resolution;
+        if (chosenResolution && 'integrity' in chosenResolution && chosenResolution.integrity != null) {
+            return `${pkgIdWithPatchHash}:${chosenResolution.integrity}`;
+        }
+    }
+    return `${pkgIdWithPatchHash}:${hashObject(resolution)}`;
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.graph-hasher",
-  "version": "1100.0.0",
+  "version": "1100.1.0",
   "description": "Calculates the state of a dependency",
   "keywords": [
     "pnpm",
@@ -24,15 +24,17 @@
     "!*.map"
   ],
   "dependencies": {
+    "detect-libc": "^2.0.3",
     "@pnpm/constants": "1100.0.0",
-    "@pnpm/deps.path": "1100.0.0",
     "@pnpm/crypto.object-hasher": "1100.0.0",
-    "@pnpm/lockfile.types": "1100.0.0",
-    "@pnpm/lockfile.utils": "1100.0.0",
-    "@pnpm/types": "1100.0.0"
+    "@pnpm/deps.path": "1100.0.1",
+    "@pnpm/lockfile.utils": "1100.0.2",
+    "@pnpm/lockfile.types": "1100.0.2",
+    "@pnpm/types": "1101.0.0",
+    "@pnpm/resolving.resolver-base": "1100.1.0"
   },
   "devDependencies": {
-    "@pnpm/deps.graph-hasher": "1100.0.0"
+    "@pnpm/deps.graph-hasher": "1100.1.0"
   },
   "engines": {
     "node": ">=22.13"