@pnpm/installing.deps-installer 1101.7.0 → 1101.9.0

package/lib/install/index.js

@@ -58,7 +58,7 @@ export async function install(manifest, opts) {
     // When a pnpr server is configured, use server-side resolution
     // instead of the normal resolution flow.
     if (opts.pnprServer) {
-        return installFromPnpmRegistry(manifest, rootDir, opts);
+        return installViaPnprServer(manifest, rootDir, opts);
     }
     const { updatedCatalogs, updatedProjects: projects, ignoredBuilds, resolutionPolicyViolations } = await mutateModules([
         {
@@ -262,7 +262,7 @@ export async function mutateModules(projects, maybeOpts) {
     }
     let ignoredBuilds = result.ignoredBuilds;
     if (!opts.ignoreScripts && ignoredBuilds?.size) {
-        ignoredBuilds = await runUnignoredDependencyBuilds(opts, ignoredBuilds, allowBuild);
+        ignoredBuilds = await runUnignoredDependencyBuilds(opts, ignoredBuilds, ctx.wantedLockfile, allowBuild);
     }
     // Detect packages whose build approval was revoked between the previous
     // and current install. A package is considered revoked when it was
@@ -277,10 +277,13 @@ export async function mutateModules(projects, maybeOpts) {
             for (const depPath of Object.keys(ctx.wantedLockfile.packages)) {
                 if (ignoredBuilds?.has(depPath))
                     continue;
-                const { name, version } = dp.parse(depPath);
-                if (!name || !version)
+                // The old policy is evaluated with identity trust overridden so that
+                // package-name approvals count as they did when they were granted,
+                // even for git/tarball artifacts that the current policy no longer
+                // approves by name.
+                if (oldAllowBuild(depPath, { trustPackageIdentity: true }) !== true)
                     continue;
-                if (oldAllowBuild(name, version) === true && allowBuild?.(name, version) === undefined) {
+                if (allowBuild?.(depPath) === undefined) {
                     ignoredBuilds ??= new Set();
                     ignoredBuilds.add(depPath);
                 }
@@ -796,19 +799,17 @@ Note that in CI environments, this setting is enabled by default.`,
         }
     }
 }
-async function runUnignoredDependencyBuilds(opts, previousIgnoredBuilds, allowBuild) {
+async function runUnignoredDependencyBuilds(opts, previousIgnoredBuilds, currentLockfile, allowBuild) {
     if (!allowBuild) {
         return previousIgnoredBuilds;
     }
     const pkgsToBuild = [];
     for (const ignoredPkg of previousIgnoredBuilds) {
-        const parsed = dp.parse(ignoredPkg);
-        if (!parsed.name || !parsed.version)
+        if (currentLockfile.packages?.[ignoredPkg] == null)
             continue;
-        const allowed = allowBuild(parsed.name, parsed.version);
-        if (allowed === true) {
+        if (allowBuild(ignoredPkg) === true) {
             // Package is explicitly allowed - rebuild it
-            pkgsToBuild.push(`${parsed.name}@${parsed.version}`);
+            pkgsToBuild.push(dp.getPkgIdWithPatchHash(ignoredPkg));
         }
     }
     if (pkgsToBuild.length) {
@@ -1572,7 +1573,7 @@ export class IgnoredBuildsError extends PnpmError {
     }
 }
 function dedupePackageNamesFromIgnoredBuilds(ignoredBuilds) {
-    return Array.from(new Set(Array.from(ignoredBuilds ?? []).map(dp.removeSuffix))).sort(lexCompare);
+    return Array.from(new Set(Array.from(ignoredBuilds ?? []).map(depPath => dp.getPkgIdWithPatchHash(depPath)))).sort(lexCompare);
 }
 /**
  * Build injectionTargetsByDepPath from the dependenciesGraph for injected workspace packages
@@ -1777,10 +1778,10 @@ async function mutateModulesViaPnpr(projects, opts) {
     const pnprProjects = await preparePnprProjects(projects, opts);
     if (!pnprProjects)
         return null;
-    // installFromPnpmRegistry runs the headless install for the first
+    // installViaPnprServer runs the headless install for the first
     // project's root and the workspace path for the rest. Pass the
     // pre-processed manifests so resolution sees the post-mutation state.
-    const result = await installFromPnpmRegistry(pnprProjects[0].manifest, pnprProjects[0].rootDir, opts, pnprProjects.map((p) => ({ rootDir: p.rootDir, manifest: p.manifest })));
+    const result = await installViaPnprServer(pnprProjects[0].manifest, pnprProjects[0].rootDir, opts, pnprProjects.map((p) => ({ rootDir: p.rootDir, manifest: p.manifest })));
     // For installSome projects, copy resolved specs from the lockfile importer
     // entries back into the client manifest so save-prefix/catalog/etc. take
     // effect (the server applies these during its resolution step).
@@ -1805,11 +1806,11 @@ async function mutateModulesViaPnpr(projects, opts) {
     };
 }
 /**
- * When a pnpr server is configured, resolve dependencies server-side
- * and download only the missing files. Then run a headless install to link
- * packages into node_modules.
+ * When a pnpr server is configured, resolve dependencies server-side,
+ * then run a headless install that fetches tarballs from the registries
+ * and links packages into node_modules — like a normal install.
  */
-async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjects) {
+async function installViaPnprServer(manifest, rootDir, opts, allInstallProjects) {
     // The pnpr server path skips client-side resolution, so resolver-side policies
     // can't be enforced locally. `minimumReleaseAge` is forwarded to the
     // pnpr server and enforced server-side. `trustPolicy` has no server-side
@@ -1818,20 +1819,14 @@ async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjec
     if (opts.trustPolicy === 'no-downgrade') {
         throw new PnpmError('TRUST_POLICY_INCOMPATIBLE_WITH_PNPR', 'The pnpr server does not yet enforce `trustPolicy: no-downgrade`, so running an install through it under this policy would produce a lockfile that the local verifier rejects.', { hint: 'Unset `trustPolicy` for this install, or disable the pnpr server (unset `--pnpr-server` / `pnprServer` in pnpm-workspace.yaml) so resolution runs locally and the trust check applies.' });
     }
-    const { fetchFromPnpmRegistry } = await import('@pnpm/pnpr.client');
+    const { resolveViaPnprServer } = await import('@pnpm/pnpr.client');
     const { createGetAuthHeaderByURI, getAuthHeadersFromCreds } = await import('@pnpm/network.auth-header');
-    const { StoreIndex } = await import('@pnpm/store.index');
-    const { setImportConcurrency } = await import('@pnpm/worker');
     // Forward the whole credential map (the registries a graph touches
     // aren't known up front), so the server attaches the right token per
     // URL. `authorization` also identifies the caller to pnpr's gate.
     const configByUri = opts.configByUri ?? {};
     const forwardedAuthHeaders = getAuthHeadersFromCreds(configByUri);
     const pnprAuthorization = createGetAuthHeaderByURI(configByUri)(opts.pnprServer);
-    // Raise import concurrency for this install only — the pnpr server path has no
-    // concurrent fetching competing for workers. Restore afterwards so we
-    // don't leak a process-wide mutation to other installs (e.g. tests).
-    const restoreImportConcurrency = setImportConcurrency(6);
     try {
         const lockfileDir = opts.lockfileDir ?? rootDir;
         // Read the existing lockfile (if any) in its on-disk shape — that's
@@ -1841,49 +1836,32 @@ async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjec
             ignoreIncompatible: true,
         }).catch(() => null);
         logger.info({ message: 'Resolving dependencies via the pnpr server', prefix: rootDir });
-        // Open the store index to read integrities and write new entries.
-        // Close it in a finally so a failure in fetchFromPnpmRegistry doesn't
-        // leak an open SQLite handle (on Windows that also blocks store cleanup).
-        const storeIndex = new StoreIndex(opts.storeDir);
-        let lockfile, pnprStats, fileDownloads, indexEntries;
-        try {
-            // Build projects list for workspace support.
-            // Normalize separators to POSIX — on Windows `path.relative` returns
-            // backslashes, which the pnpr server rejects (it treats `\` as an
-            // unsafe/YAML-injection character and normalizes paths as POSIX).
-            const projectsList = allInstallProjects && allInstallProjects.length > 1
-                ? allInstallProjects.map(p => ({
-                    dir: (path.relative(lockfileDir, p.rootDir) || '.').split(path.sep).join('/'),
-                    dependencies: p.manifest.dependencies,
-                    devDependencies: p.manifest.devDependencies,
-                    optionalDependencies: p.manifest.optionalDependencies,
-                }))
-                : undefined;
-            ({ lockfile, stats: pnprStats, fileDownloads, indexEntries } = await fetchFromPnpmRegistry({
-                registryUrl: opts.pnprServer,
-                storeDir: opts.storeDir,
-                storeIndex,
-                dependencies: projectsList ? undefined : manifest.dependencies,
-                devDependencies: projectsList ? undefined : manifest.devDependencies,
-                optionalDependencies: projectsList ? undefined : manifest.optionalDependencies,
-                projects: projectsList,
-                registry: opts.registries?.default,
-                namedRegistries: opts.namedRegistries,
-                authHeaders: forwardedAuthHeaders,
-                authorization: pnprAuthorization,
-                overrides: opts.overrides,
-                minimumReleaseAge: opts.minimumReleaseAge,
-                lockfile: existingLockfile ?? undefined,
-                lockfileOnly: opts.lockfileOnly,
-            }));
-            // Write store index entries so headless install finds them.
-            const { writeRawIndexEntries } = await import('@pnpm/pnpr.client');
-            writeRawIndexEntries(indexEntries, storeIndex);
-            storeIndex.checkpoint();
-        }
-        finally {
-            storeIndex.close();
-        }
+        // Build projects list for workspace support.
+        // Normalize separators to POSIX — on Windows `path.relative` returns
+        // backslashes, which the pnpr server rejects (it treats `\` as an
+        // unsafe/YAML-injection character and normalizes paths as POSIX).
+        const projectsList = allInstallProjects && allInstallProjects.length > 1
+            ? allInstallProjects.map(p => ({
+                dir: (path.relative(lockfileDir, p.rootDir) || '.').split(path.sep).join('/'),
+                dependencies: p.manifest.dependencies,
+                devDependencies: p.manifest.devDependencies,
+                optionalDependencies: p.manifest.optionalDependencies,
+            }))
+            : undefined;
+        const { lockfile, stats: pnprStats } = await resolveViaPnprServer({
+            registryUrl: opts.pnprServer,
+            dependencies: projectsList ? undefined : manifest.dependencies,
+            devDependencies: projectsList ? undefined : manifest.devDependencies,
+            optionalDependencies: projectsList ? undefined : manifest.optionalDependencies,
+            projects: projectsList,
+            registry: opts.registries?.default,
+            namedRegistries: opts.namedRegistries,
+            authHeaders: forwardedAuthHeaders,
+            authorization: pnprAuthorization,
+            overrides: opts.overrides,
+            minimumReleaseAge: opts.minimumReleaseAge,
+            lockfile: existingLockfile ?? undefined,
+        });
         await writeWantedLockfileAndRecordVerified({
             lockfileDir,
             lockfile,
@@ -1893,17 +1871,13 @@ async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjec
             mergeGitBranchLockfiles: opts.mergeGitBranchLockfiles,
         });
         logger.info({
-            message: `Resolved ${pnprStats.totalPackages} packages: ${pnprStats.alreadyInStore} cached, ${pnprStats.filesToDownload} files to download`,
+            message: `Resolved ${pnprStats.totalPackages} packages`,
             prefix: rootDir,
         });
         // `--lockfile-only`: the pnpr server resolved and we wrote the lockfile, but
         // pnpm fetches nothing and links nothing in this mode — stop before the
         // headless install. See https://github.com/pnpm/pnpm/issues/12146.
         if (opts.lockfileOnly) {
-            // Nothing is downloaded in this mode, but the lockfile arrives before
-            // the stream closes — observe `fileDownloads` so a stream error after
-            // the `L` frame doesn't surface as an unhandled rejection.
-            void fileDownloads.catch(() => { });
             return {
                 updatedCatalogs: undefined,
                 updatedManifest: manifest,
@@ -1913,43 +1887,12 @@ async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjec
                 resolutionPolicyViolations: [],
             };
         }
-        // Wrap fetchPackage to:
-        // 1. Wait for pnpr server file downloads before checking the store
-        // 2. Skip integrity verification — files just written from the pnpr server
-        //    are guaranteed correct (server verified, no rehashing needed)
-        const { readPkgFromCafs } = await import('@pnpm/worker');
-        const { storeIndexKey: _storeIndexKey } = await import('@pnpm/store.index');
-        const wrappedStoreController = {
-            ...opts.storeController,
-            fetchPackage: async (fetchOpts) => {
-                await fileDownloads;
-                const resolution = fetchOpts.pkg.resolution;
-                const integrity = resolution?.integrity;
-                // Fall through to the regular store controller for git-hosted tarballs.
-                // Their cached entry lives under gitHostedStoreIndexKey (preserves the
-                // built/not-built dimension), not the integrity-keyed path the pnpr server
-                // uses for npm tarballs. See @pnpm/store.pkg-finder for the rationale.
-                if (integrity && !resolution?.gitHosted) {
-                    const filesIndexFile = _storeIndexKey(integrity, fetchOpts.pkg.id);
-                    const result = await readPkgFromCafs({ storeDir: opts.storeDir, verifyStoreIntegrity: false }, filesIndexFile, { readManifest: true, expectedPkg: { name: fetchOpts.pkg.name, version: fetchOpts.pkg.version } });
-                    return {
-                        fetching: () => Promise.resolve({
-                            files: result.files,
-                            bundledManifest: result.bundledManifest,
-                            integrity,
-                        }),
-                        filesIndexFile,
-                    };
-                }
-                return opts.storeController.fetchPackage(fetchOpts);
-            },
-        };
+        // The pnpr server only resolves; it serves no file content. Fetch every
+        // tarball from the registries with the regular store controller, in
+        // parallel, exactly like a normal install. See
+        // https://github.com/pnpm/pnpm/issues/12230.
         const headlessOpts = {
             ...opts,
-            // Skip re-verifying files just written from the pnpr server — they're
-            // guaranteed correct (server verified, no rehashing needed).
-            verifyStoreIntegrity: false,
-            storeController: wrappedStoreController,
             dir: rootDir,
             lockfileDir,
             engineStrict: opts.engineStrict ?? false,
@@ -2006,7 +1949,6 @@ async function installFromPnpmRegistry(manifest, rootDir, opts, allInstallProjec
         // normal install path does the same; skipping it here would leave
         // pending writes on disk and diverge from lifecycle expectations.
         await opts.storeController.close();
-        restoreImportConcurrency();
     }
 }
 //# sourceMappingURL=index.js.map

package/lib/install/link.js

@@ -328,7 +328,7 @@ async function linkAllPkgs(storeController, depNodes, opts) {
         depNode.requiresBuild = files.requiresBuild;
         let sideEffectsCacheKey;
         if (opts.sideEffectsCacheRead && files.sideEffectsMaps && !isEmpty(files.sideEffectsMaps)) {
-            if (opts.allowBuild?.(depNode.name, depNode.version) === true) {
+            if (opts.allowBuild?.(depNode.depPath) === true) {
                 sideEffectsCacheKey = calcDepState(opts.depGraph, opts.depsStateCache, depNode.depPath, {
                     includeDepGraphHash: !opts.ignoreScripts && depNode.requiresBuild, // true when is built
                     patchFileHash: depNode.patch?.hash,

package/lib/install/recordLockfileVerified.js

@@ -1,4 +1,5 @@
 import { hashObject } from '@pnpm/crypto.object-hasher';
+import { withResolutionShapeCacheIdentity } from './verifyLockfileResolutions.js';
 import { recordVerification } from './verifyLockfileResolutionsCache.js';
 /**
  * Records the post-resolution lockfile as verified so the next install
@@ -17,7 +18,7 @@ export function recordLockfileVerified(opts) {
         return;
     recordVerification(opts.cacheDir, {
         lockfilePath: opts.lockfilePath,
-        verifiers: opts.resolutionVerifiers,
+        verifiers: withResolutionShapeCacheIdentity(opts.resolutionVerifiers),
         hashLockfile: () => hashObject(opts.lockfile),
     });
 }

package/lib/install/verifyLockfileResolutions.d.ts

@@ -1,6 +1,17 @@
 import type { LockfileObject } from '@pnpm/lockfile.fs';
 import type { ResolutionPolicyViolation, ResolutionVerifier } from '@pnpm/resolving.resolver-base';
+import { type VerifierCacheIdentity } from './verifyLockfileResolutionsCache.js';
 export type { ResolutionPolicyViolation };
+export declare const RESOLUTION_SHAPE_MISMATCH_VIOLATION_CODE = "RESOLUTION_SHAPE_MISMATCH";
+/**
+ * Every verifier list that flows into the verification cache must carry
+ * the resolution-shape identity, so records written before the shape rule
+ * existed cannot stat-fast-path around it. Used by the gate itself and by
+ * {@link recordLockfileVerified}, whose freshly-resolved lockfile satisfies
+ * the shape invariant by construction (the writer derives every key from
+ * the resolution it just produced).
+ */
+export declare function withResolutionShapeCacheIdentity(verifiers: readonly VerifierCacheIdentity[]): VerifierCacheIdentity[];
 export interface VerifyLockfileResolutionsOptions {
     concurrency?: number;
     /**

package/lib/install/verifyLockfileResolutions.js

@@ -1,17 +1,33 @@
 import { lockfileVerificationLogger } from '@pnpm/core-loggers';
 import { hashObject } from '@pnpm/crypto.object-hasher';
 import { PnpmError } from '@pnpm/error';
-import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
+import { isGitHostedTarballUrl, nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
 import pLimit from 'p-limit';
 import { recordVerification, tryLockfileVerificationCache, } from './verifyLockfileResolutionsCache.js';
 // Cap the per-entry breakdown so a verifier rejecting hundreds of entries
 // (e.g. a poisoned lockfile) doesn't flood the terminal / CI log; the full
 // count is in the header and the remainder is summarized at the end.
 const MAX_VIOLATIONS_TO_PRINT = 20;
-// 16 mirrors the floor of pnpm's package-requester network-concurrency
-// (Math.min(64, Math.max(workers*3, 16))); keep them aligned so the
+// 64 mirrors the floor of pnpm's package-requester network-concurrency
+// (Math.min(96, Math.max(workers*3, 64))); keep them aligned so the
 // verification pass doesn't push past what the rest of the install respects.
-const DEFAULT_CONCURRENCY = 16;
+const DEFAULT_CONCURRENCY = 64;
+export const RESOLUTION_SHAPE_MISMATCH_VIOLATION_CODE = 'RESOLUTION_SHAPE_MISMATCH';
+const RESOLUTION_SHAPE_CACHE_IDENTITY = {
+    policy: { resolutionShapeCheck: true },
+    canTrustPastCheck: (cached) => cached.resolutionShapeCheck === true,
+};
+/**
+ * Every verifier list that flows into the verification cache must carry
+ * the resolution-shape identity, so records written before the shape rule
+ * existed cannot stat-fast-path around it. Used by the gate itself and by
+ * {@link recordLockfileVerified}, whose freshly-resolved lockfile satisfies
+ * the shape invariant by construction (the writer derives every key from
+ * the resolution it just produced).
+ */
+export function withResolutionShapeCacheIdentity(verifiers) {
+    return [...verifiers, RESOLUTION_SHAPE_CACHE_IDENTITY];
+}
 /**
  * Policy-neutral pass that asks every resolver-supplied
  * {@link ResolutionVerifier} to check every entry in a lockfile loaded
@@ -40,8 +56,6 @@ const DEFAULT_CONCURRENCY = 16;
  * the lookup logic.
  */
 export async function verifyLockfileResolutions(lockfile, verifiers, options) {
-    if (verifiers.length === 0)
-        return;
     if (!lockfile.packages)
         return;
     // Caching kicks in only when the caller surfaced both a writable
@@ -51,6 +65,7 @@ export async function verifyLockfileResolutions(lockfile, verifiers, options) {
     const cache = options?.cacheDir && options?.lockfilePath
         ? { cacheDir: options.cacheDir, lockfilePath: options.lockfilePath }
         : undefined;
+    const cacheVerifiers = withResolutionShapeCacheIdentity(verifiers);
     let cachePrecomputed;
     // hashObject streams and is key-order-stable, unlike JSON.stringify.
     let cachedHash;
@@ -62,26 +77,44 @@ export async function verifyLockfileResolutions(lockfile, verifiers, options) {
     if (cache) {
         const result = tryLockfileVerificationCache(cache.cacheDir, {
             lockfilePath: cache.lockfilePath,
-            verifiers,
+            verifiers: cacheVerifiers,
             hashLockfile,
         });
-        if (result.hit)
+        if (result.hit) {
+            // A silent short-circuit looks like the policy gate never ran
+            // (pnpm/pnpm#12324), so surface the reused verdict — but only
+            // when policy verifiers are active; the shape-only run that
+            // every install performs stays quiet.
+            if (verifiers.length > 0) {
+                lockfileVerificationLogger.debug({
+                    status: 'cached',
+                    verifiedAt: result.verifiedAt,
+                    lockfilePath: options?.lockfilePath,
+                });
+            }
             return;
+        }
         cachePrecomputed = result.precomputed;
     }
     // Emit started/done around the actual verification pass — the
     // round-trip can be slow on a cold registry cache, and the cached
-    // short-circuit above doesn't reach this branch, so a user only
-    // sees these messages on installs that are doing real work.
+    // short-circuit above announces itself with its own `cached` event,
+    // so a user only sees these messages on installs that are doing
+    // real work.
     // A degenerate lockfile where every snapshot fails the
     // name/version extraction (so candidates is empty) skips emission
     // entirely — no work, no noise.
-    const candidates = collectCandidates(lockfile);
+    const { candidates, shapeViolations } = collectCandidates(lockfile);
+    if (shapeViolations.length > 0) {
+        throw buildVerificationError(shapeViolations);
+    }
+    if (verifiers.length === 0)
+        return;
     if (candidates.size === 0) {
         if (cache) {
             recordVerification(cache.cacheDir, {
                 lockfilePath: cache.lockfilePath,
-                verifiers,
+                verifiers: cacheVerifiers,
                 hashLockfile,
             }, cachePrecomputed);
         }
@@ -108,7 +141,7 @@ export async function verifyLockfileResolutions(lockfile, verifiers, options) {
             if (cache) {
                 recordVerification(cache.cacheDir, {
                     lockfilePath: cache.lockfilePath,
-                    verifiers,
+                    verifiers: cacheVerifiers,
                     hashLockfile,
                 }, cachePrecomputed);
             }
@@ -174,7 +207,48 @@ export async function collectResolutionPolicyViolations(lockfile, verifiers, opt
         return [];
     if (!lockfile.packages)
         return [];
-    return iterateLockfileViolations(collectCandidates(lockfile), verifiers, options?.concurrency);
+    // Shape violations are deliberately not collected here: they are hard
+    // tampering failures, not policy picks a caller may auto-exclude.
+    return iterateLockfileViolations(collectCandidates(lockfile).candidates, verifiers, options?.concurrency);
+}
+function isRegistryShapedResolution(resolution) {
+    if (resolution == null)
+        return true;
+    if (typeof resolution !== 'object')
+        return false;
+    const { type, gitHosted, tarball, variants } = resolution;
+    if (type === 'variations') {
+        return Array.isArray(variants) && variants.every((variant) => isRegistryShapedResolution(variant?.resolution));
+    }
+    // Custom resolver protocols (`type: 'custom:*'`) are a legitimate
+    // non-registry source the user opted into. They can only be materialized by
+    // a project-configured custom fetcher — an unrecognized custom type throws at
+    // fetch time (see @pnpm/fetching.pick-fetcher) — so a forged custom type
+    // cannot launder an artifact past this gate into a build.
+    if (typeof type === 'string' && type.startsWith('custom:'))
+        return true;
+    if (type != null)
+        return false;
+    // Plain tarball / registry resolution. The lockfile is parsed from YAML
+    // without schema validation, so the `gitHosted` flag is not trustworthy on
+    // its own: a tampered entry could set a non-boolean (dodging a strict
+    // `=== true`) or an explicit `false` on a git-host URL (the loader only
+    // backfills the flag when absent). Treat any non-boolean flag as git-hosted
+    // and gate on the URL so the verdict never depends on the flag alone.
+    if (gitHosted != null && (typeof gitHosted !== 'boolean' || gitHosted))
+        return false;
+    // A registry resolution reconstructs its tarball URL from name+version, so
+    // an absent/empty `tarball` is registry-shaped. When a URL is present it
+    // must be an http(s) registry artifact: the npm verifier's tarball-URL
+    // binding skips non-http(s) schemes (file:, etc.), so a `file:` tarball
+    // under a name@semver key would otherwise be trusted with no safety net.
+    if (typeof tarball === 'string' && tarball !== '') {
+        if (!/^https?:\/\//i.test(tarball))
+            return false;
+        if (isGitHostedTarballUrl(tarball))
+            return false;
+    }
+    return true;
 }
 // depPath can include peer-dependency and patch_hash suffixes (e.g.
 // `react@18.0.0(peer)(patch_hash=…)`); the same (name, version) pair may
@@ -191,10 +265,25 @@ export async function collectResolutionPolicyViolations(lockfile, verifiers, opt
 // never checked.
 function collectCandidates(lockfile) {
     const candidates = new Map();
+    const shapeViolations = [];
     for (const [depPath, snapshot] of Object.entries(lockfile.packages ?? {})) {
         const { name, version, nonSemverVersion } = nameVerFromPkgSnapshot(depPath, snapshot);
         if (!name || !version)
             continue;
+        // A registry-style depPath (name@semver) must be backed by a
+        // registry-shaped resolution: the allowBuilds policy derives a
+        // trusted package identity from that key shape, which is only sound
+        // while this invariant holds. The check is offline, so it applies
+        // even when no policy verifiers are active.
+        if (nonSemverVersion == null && !isRegistryShapedResolution(snapshot.resolution)) {
+            shapeViolations.push({
+                name,
+                version,
+                resolution: snapshot.resolution,
+                code: RESOLUTION_SHAPE_MISMATCH_VIOLATION_CODE,
+                reason: 'a registry-style dependency path is backed by a non-registry resolution',
+            });
+        }
         const key = `${name}@${version}@${nonSemverVersion ?? ''}@${JSON.stringify(snapshot.resolution)}`;
         candidates.set(key, {
             name,
@@ -203,7 +292,7 @@ function collectCandidates(lockfile) {
             resolution: snapshot.resolution,
         });
     }
-    return candidates;
+    return { candidates, shapeViolations };
 }
 async function iterateLockfileViolations(candidates, verifiers, concurrency) {
     const violations = [];

package/lib/install/verifyLockfileResolutionsCache.d.ts

@@ -9,6 +9,13 @@ import type { ResolutionVerifier } from '@pnpm/resolving.resolver-base';
 export type VerifierCacheIdentity = Pick<ResolutionVerifier, 'policy' | 'canTrustPastCheck'>;
 export interface CacheLookupResult {
     hit: boolean;
+    /**
+     * ISO-8601 timestamp of the verification run the hit is reusing.
+     * Set only on a hit, and only when the record carries a usable
+     * timestamp (records written before the field existed normalize to
+     * an empty string and surface as `undefined` here).
+     */
+    verifiedAt?: string;
     /**
      * stat + hash already computed during the lookup. When the caller
      * follows up with {@link recordVerification} after running the gate,

package/lib/install/verifyLockfileResolutionsCache.js

@@ -159,8 +159,10 @@ export function tryLockfileVerificationCache(cacheDir, key) {
     // hash without reading the file. Microseconds.
     const byPathRecord = indexes.byPath.get(key.lockfilePath);
     if (byPathRecord && statMatches(stat, byPathRecord.lockfile)) {
+        const hit = everyVerifierTrustsCachedRun(byPathRecord, key.verifiers);
         return {
-            hit: everyVerifierTrustsCachedRun(byPathRecord, key.verifiers),
+            hit,
+            verifiedAt: hit ? byPathRecord.verifiedAt || undefined : undefined,
             // The stat-match implies the file content is unchanged since the
             // cached record was written, so its hash is still correct. Pass
             // it through to skip hashing on the miss-then-record path.
@@ -190,7 +192,7 @@ export function tryLockfileVerificationCache(cacheDir, key) {
         ...byHashRecord,
         lockfile: { ...byHashRecord.lockfile, path: key.lockfilePath, size: stat.size, mtimeNs: stat.mtimeNs, inode: stat.inode },
     });
-    return { hit: true, precomputed: { stat, hash } };
+    return { hit: true, verifiedAt: byHashRecord.verifiedAt || undefined, precomputed: { stat, hash } };
 }
 function everyVerifierTrustsCachedRun(record, verifiers) {
     for (const verifier of verifiers) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/installing.deps-installer",
-  "version": "1101.7.0",
+  "version": "1101.9.0",
   "description": "Fast, disk space efficient installation engine",
   "keywords": [
     "pnpm",
@@ -65,61 +65,61 @@
     "ramda": "npm:@pnpm/ramda@0.28.1",
     "run-groups": "^5.0.0",
     "semver": "^7.8.1",
-    "@pnpm/building.after-install": "1101.0.19",
-    "@pnpm/bins.linker": "1100.0.11",
-    "@pnpm/building.policy": "1100.0.8",
+    "@pnpm/bins.linker": "1100.0.13",
+    "@pnpm/building.after-install": "1101.0.21",
+    "@pnpm/building.during-install": "1101.0.18",
+    "@pnpm/building.policy": "1100.0.9",
     "@pnpm/catalogs.resolver": "1100.0.0",
-    "@pnpm/config.matcher": "1100.0.1",
-    "@pnpm/catalogs.protocol-parser": "1100.0.0",
-    "@pnpm/building.during-install": "1101.0.16",
-    "@pnpm/config.normalize-registries": "1100.0.6",
-    "@pnpm/core-loggers": "1100.1.3",
-    "@pnpm/bins.remover": "1100.0.7",
     "@pnpm/catalogs.types": "1100.0.0",
-    "@pnpm/deps.graph-sequencer": "1100.0.0",
+    "@pnpm/catalogs.protocol-parser": "1100.0.0",
+    "@pnpm/config.parse-overrides": "1100.0.1",
     "@pnpm/constants": "1100.0.0",
-    "@pnpm/crypto.object-hasher": "1100.0.0",
-    "@pnpm/deps.path": "1100.0.6",
-    "@pnpm/deps.graph-hasher": "1100.2.3",
+    "@pnpm/config.matcher": "1100.0.1",
+    "@pnpm/config.normalize-registries": "1100.0.7",
+    "@pnpm/core-loggers": "1100.2.0",
+    "@pnpm/deps.graph-hasher": "1100.2.4",
+    "@pnpm/crypto.hash": "1100.0.1",
+    "@pnpm/deps.graph-sequencer": "1100.0.0",
     "@pnpm/error": "1100.0.0",
-    "@pnpm/config.parse-overrides": "1100.0.1",
-    "@pnpm/exec.lifecycle": "1100.0.15",
-    "@pnpm/hooks.read-package-hook": "1100.0.6",
+    "@pnpm/deps.path": "1100.0.7",
+    "@pnpm/exec.lifecycle": "1100.0.17",
+    "@pnpm/fs.symlink-dependency": "1100.0.9",
+    "@pnpm/crypto.object-hasher": "1100.0.0",
+    "@pnpm/hooks.read-package-hook": "1100.0.7",
+    "@pnpm/hooks.types": "1100.0.11",
+    "@pnpm/installing.deps-resolver": "1100.2.2",
+    "@pnpm/bins.remover": "1100.0.9",
+    "@pnpm/installing.context": "1100.0.17",
+    "@pnpm/installing.linking.hoist": "1100.0.13",
+    "@pnpm/installing.deps-restorer": "1101.1.11",
+    "@pnpm/installing.linking.modules-cleaner": "1100.1.7",
+    "@pnpm/installing.linking.direct-dep-linker": "1100.0.9",
+    "@pnpm/installing.modules-yaml": "1100.0.8",
+    "@pnpm/lockfile.filtering": "1100.1.6",
+    "@pnpm/lockfile.fs": "1100.1.4",
+    "@pnpm/installing.package-requester": "1101.1.0",
+    "@pnpm/lockfile.preferred-versions": "1100.0.15",
     "@pnpm/fs.read-modules-dir": "1100.0.1",
-    "@pnpm/hooks.types": "1100.0.10",
-    "@pnpm/installing.context": "1100.0.15",
-    "@pnpm/crypto.hash": "1100.0.1",
-    "@pnpm/installing.deps-resolver": "1100.2.0",
-    "@pnpm/installing.deps-restorer": "1101.1.9",
-    "@pnpm/installing.linking.direct-dep-linker": "1100.0.7",
-    "@pnpm/installing.linking.hoist": "1100.0.11",
-    "@pnpm/installing.modules-yaml": "1100.0.7",
-    "@pnpm/installing.package-requester": "1101.0.11",
-    "@pnpm/lockfile.fs": "1100.1.3",
-    "@pnpm/lockfile.filtering": "1100.1.4",
-    "@pnpm/lockfile.to-pnp": "1100.0.12",
-    "@pnpm/lockfile.preferred-versions": "1100.0.13",
-    "@pnpm/lockfile.utils": "1100.0.11",
-    "@pnpm/lockfile.walker": "1100.0.9",
-    "@pnpm/network.auth-header": "1101.1.0",
-    "@pnpm/pkg-manifest.utils": "1100.2.2",
-    "@pnpm/patching.config": "1100.0.6",
-    "@pnpm/lockfile.pruner": "1100.0.9",
+    "@pnpm/lockfile.settings-checker": "1100.0.17",
+    "@pnpm/lockfile.to-pnp": "1100.0.13",
+    "@pnpm/lockfile.pruner": "1100.0.10",
+    "@pnpm/lockfile.utils": "1100.0.12",
+    "@pnpm/lockfile.walker": "1100.0.10",
+    "@pnpm/network.auth-header": "1101.1.1",
+    "@pnpm/lockfile.verification": "1100.0.17",
+    "@pnpm/patching.config": "1100.0.7",
+    "@pnpm/pnpr.client": "1.2.0",
+    "@pnpm/pkg-manifest.utils": "1100.2.4",
+    "@pnpm/store.controller-types": "1100.1.4",
     "@pnpm/store.index": "1100.1.0",
-    "@pnpm/resolving.resolver-base": "1100.4.0",
+    "@pnpm/resolving.resolver-base": "1100.4.1",
+    "@pnpm/types": "1101.3.1",
     "@pnpm/resolving.parse-wanted-dependency": "1100.0.1",
-    "@pnpm/workspace.project-manifest-reader": "1100.0.10",
-    "@pnpm/pnpr.client": "1.1.0",
-    "@pnpm/types": "1101.3.0",
-    "@pnpm/lockfile.settings-checker": "1100.0.15",
-    "@pnpm/installing.linking.modules-cleaner": "1100.1.5",
-    "@pnpm/store.controller-types": "1100.1.3",
-    "@pnpm/lockfile.verification": "1100.0.15",
-    "@pnpm/fs.symlink-dependency": "1100.0.7"
+    "@pnpm/workspace.project-manifest-reader": "1100.0.12"
   },
   "peerDependencies": {
     "@pnpm/logger": "^1001.0.1",
-    "@pnpm/worker": "^1100.1.9"
+    "@pnpm/worker": "^1100.1.11"
   },
   "devDependencies": {
     "@jest/globals": "30.3.0",
@@ -141,22 +141,22 @@
     "symlink-dir": "^10.0.1",
     "write-json-file": "^7.0.0",
     "write-yaml-file": "^6.0.0",
-    "@pnpm/assert-project": "1100.0.13",
-    "@pnpm/lockfile.types": "1100.0.9",
-    "@pnpm/installing.deps-installer": "1101.7.0",
-    "@pnpm/prepare": "1100.0.13",
-    "@pnpm/pkg-manifest.reader": "1100.0.6",
-    "@pnpm/network.git-utils": "1100.0.1",
+    "@pnpm/assert-project": "1100.0.15",
+    "@pnpm/assert-store": "1100.0.15",
+    "@pnpm/installing.deps-installer": "1101.9.0",
     "@pnpm/logger": "1100.0.0",
-    "@pnpm/resolving.registry.types": "1100.1.1",
-    "@pnpm/store.cafs": "1100.1.8",
-    "@pnpm/testing.mock-agent": "1101.0.0",
-    "@pnpm/test-ipc-server": "1100.0.0",
+    "@pnpm/network.git-utils": "1100.0.1",
+    "@pnpm/lockfile.types": "1100.0.10",
+    "@pnpm/resolving.registry.types": "1100.1.2",
+    "@pnpm/pkg-manifest.reader": "1100.0.7",
+    "@pnpm/store.cafs": "1100.1.9",
     "@pnpm/store.path": "1100.0.1",
+    "@pnpm/prepare": "1100.0.15",
+    "@pnpm/test-ipc-server": "1100.0.0",
     "@pnpm/test-fixtures": "1100.0.0",
-    "@pnpm/testing.registry-mock": "1100.0.3",
-    "@pnpm/testing.temp-store": "1100.1.6",
-    "@pnpm/assert-store": "1100.0.13"
+    "@pnpm/testing.mock-agent": "1101.0.2",
+    "@pnpm/testing.temp-store": "1100.1.8",
+    "@pnpm/testing.registry-mock": "1100.0.5"
   },
   "engines": {
     "node": ">=22.13"