@pnpm/installing.package-requester 1008.0.0

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,17 @@
+# @pnpm/package-requester
+
+> Concurrent downloader of npm-compatible packages
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/package-requester.svg)](https://www.npmjs.com/package/@pnpm/package-requester)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/logger @pnpm/package-requester
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { createPackageRequester } from './packageRequester.js';
+export type { PackageResponse } from '@pnpm/store.controller-types';

package/lib/index.js

@@ -0,0 +1,2 @@
+export { createPackageRequester } from './packageRequester.js';
+//# sourceMappingURL=index.js.map

package/lib/packageRequester.d.ts

@@ -0,0 +1,25 @@
+import type { Fetchers } from '@pnpm/fetching.fetcher-base';
+import type { CustomFetcher } from '@pnpm/hooks.types';
+import type { ResolveFunction } from '@pnpm/resolving.resolver-base';
+import type { Cafs } from '@pnpm/store.cafs-types';
+import type { FetchPackageToStoreFunction, GetFilesIndexFilePath, RequestPackageFunction } from '@pnpm/store.controller-types';
+export declare function createPackageRequester(opts: {
+    engineStrict?: boolean;
+    force?: boolean;
+    nodeVersion?: string;
+    pnpmVersion?: string;
+    resolve: ResolveFunction;
+    fetchers: Fetchers;
+    cafs: Cafs;
+    ignoreFile?: (filename: string) => boolean;
+    networkConcurrency?: number;
+    storeDir: string;
+    verifyStoreIntegrity: boolean;
+    virtualStoreDirMaxLength: number;
+    strictStorePkgContentCheck?: boolean;
+    customFetchers?: CustomFetcher[];
+}): RequestPackageFunction & {
+    fetchPackageToStore: FetchPackageToStoreFunction;
+    getFilesIndexFilePath: GetFilesIndexFilePath;
+    requestPackage: RequestPackageFunction;
+};

package/lib/packageRequester.js

@@ -0,0 +1,468 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { packageIsInstallable } from '@pnpm/config.package-is-installable';
+import { fetchingProgressLogger, progressLogger } from '@pnpm/core-loggers';
+import { depPathToFilename } from '@pnpm/deps.path';
+import { PnpmError } from '@pnpm/error';
+import { pickFetcher } from '@pnpm/fetching.pick-fetcher';
+import gfs from '@pnpm/fs.graceful-fs';
+import { logger } from '@pnpm/logger';
+import { normalizeBundledManifest, } from '@pnpm/store.cafs';
+import { gitHostedStoreIndexKey, storeIndexKey } from '@pnpm/store.index';
+import { calcMaxWorkers, readPkgFromCafs as _readPkgFromCafs, } from '@pnpm/worker';
+import { familySync } from 'detect-libc';
+import { loadJsonFile } from 'load-json-file';
+import pDefer, {} from 'p-defer';
+import PQueue from 'p-queue';
+import { pShare } from 'promise-share';
+import { pick } from 'ramda';
+import ssri from 'ssri';
+let currentLibc;
+function getLibcFamilySync() {
+    if (currentLibc === undefined) {
+        currentLibc = familySync();
+    }
+    return currentLibc;
+}
+const TARBALL_INTEGRITY_FILENAME = 'tarball-integrity';
+const packageRequestLogger = logger('package-requester');
+export function createPackageRequester(opts) {
+    opts = opts || {};
+    const networkConcurrency = opts.networkConcurrency ?? Math.min(64, Math.max(calcMaxWorkers() * 3, 16));
+    const requestsQueue = new PQueue({
+        concurrency: networkConcurrency,
+    });
+    const fetch = fetcher.bind(null, opts.fetchers, opts.cafs, opts.customFetchers);
+    const readPkgFromCafs = _readPkgFromCafs.bind(null, {
+        storeDir: opts.storeDir,
+        verifyStoreIntegrity: opts.verifyStoreIntegrity,
+        strictStorePkgContentCheck: opts.strictStorePkgContentCheck,
+    });
+    const fetchPackageToStore = fetchToStore.bind(null, {
+        readPkgFromCafs,
+        fetch,
+        fetchingLocker: new Map(),
+        requestsQueue: Object.assign(requestsQueue, {
+            counter: 0,
+            concurrency: networkConcurrency,
+        }),
+        storeDir: opts.storeDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        strictStorePkgContentCheck: opts.strictStorePkgContentCheck,
+    });
+    const requestPackage = resolveAndFetch.bind(null, {
+        engineStrict: opts.engineStrict,
+        nodeVersion: opts.nodeVersion,
+        pnpmVersion: opts.pnpmVersion,
+        force: opts.force,
+        fetchPackageToStore,
+        requestsQueue,
+        resolve: opts.resolve,
+        storeDir: opts.storeDir,
+    });
+    return Object.assign(requestPackage, {
+        fetchPackageToStore,
+        getFilesIndexFilePath: getFilesIndexFilePath.bind(null, {
+            storeDir: opts.storeDir,
+            virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        }),
+        requestPackage,
+    });
+}
+async function resolveAndFetch(ctx, wantedDependency, options) {
+    let resolution = options.currentPkg?.resolution;
+    let pkgId = options.currentPkg?.id;
+    // 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.
+    //
+    // 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 = (resolution && !options.update && 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(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, } = resolveResult;
+    // Check if the integrity has changed between the current and newly resolved package
+    // Use 'in' check to safely access integrity from any resolution type that has it
+    const previousResolution = options.currentPkg?.resolution;
+    const previousIntegrity = previousResolution && 'integrity' in previousResolution ? previousResolution.integrity : undefined;
+    const newIntegrity = 'integrity' in resolveResult.resolution ? resolveResult.resolution.integrity : undefined;
+    const integrityChanged = previousIntegrity != null && newIntegrity != null && previousIntegrity !== newIntegrity;
+    const updated = pkgId !== resolveResult.id || !resolution || integrityChanged;
+    resolution = resolveResult.resolution;
+    pkgId = resolveResult.id;
+    const id = pkgId;
+    if ('type' in resolution && resolution.type === 'directory' && !id.startsWith('file:')) {
+        if (manifest == null) {
+            throw new Error(`Couldn't read package.json of local dependency ${wantedDependency.alias ? wantedDependency.alias + '@' : ''}${wantedDependency.bareSpecifier ?? ''}`);
+        }
+        return {
+            body: {
+                id,
+                isLocal: true,
+                manifest,
+                resolution: resolution,
+                resolvedVia,
+                updated,
+                normalizedBareSpecifier,
+                alias,
+            },
+        };
+    }
+    let isInstallable = (ctx.force === true ||
+        (manifest == null
+            ? undefined
+            : packageIsInstallable(id, manifest, {
+                engineStrict: ctx.engineStrict,
+                lockfileDir: options.lockfileDir,
+                nodeVersion: ctx.nodeVersion,
+                optional: wantedDependency.optional === true,
+                supportedArchitectures: options.supportedArchitectures,
+            })));
+    // We can skip fetching the package only if the manifest
+    // is present after resolution AND the content of the package has not changed
+    if ((options.skipFetch === true || isInstallable === false) && !integrityChanged && (manifest != null)) {
+        return {
+            body: {
+                id,
+                isLocal: false,
+                isInstallable: isInstallable ?? undefined,
+                latest,
+                manifest,
+                normalizedBareSpecifier,
+                resolution,
+                resolvedVia,
+                updated,
+                publishedAt,
+                alias,
+            },
+        };
+    }
+    const pkg = manifest != null ? pick(['name', 'version'], manifest) : {};
+    const fetchResult = ctx.fetchPackageToStore({
+        allowBuild: options.allowBuild,
+        fetchRawManifest: true,
+        force: integrityChanged,
+        ignoreScripts: options.ignoreScripts,
+        lockfileDir: options.lockfileDir,
+        pkg: {
+            ...(options.expectedPkg?.name != null
+                ? (updated ? { name: options.expectedPkg.name, version: pkg.version } : options.expectedPkg)
+                : pkg),
+            id,
+            resolution,
+        },
+        onFetchError: options.onFetchError,
+        supportedArchitectures: options.supportedArchitectures,
+    });
+    if (!manifest) {
+        const fetchedResult = await fetchResult.fetching();
+        if (fetchedResult.bundledManifest) {
+            manifest = fetchedResult.bundledManifest;
+        }
+        else if (fetchedResult.files.filesMap.has('package.json')) {
+            manifest = await loadJsonFile(fetchedResult.files.filesMap.get('package.json'));
+        }
+        // Add integrity to resolution if it was computed during fetching (only for TarballResolution)
+        if (fetchedResult.integrity && !resolution.type && !resolution.integrity) {
+            resolution.integrity = fetchedResult.integrity;
+        }
+    }
+    // Check installability now that we have the manifest (for git/tarball packages without registry metadata)
+    if (isInstallable === undefined && manifest != null) {
+        isInstallable = ctx.force === true || packageIsInstallable(id, manifest, {
+            engineStrict: ctx.engineStrict,
+            lockfileDir: options.lockfileDir,
+            nodeVersion: ctx.nodeVersion,
+            optional: wantedDependency.optional === true,
+            supportedArchitectures: options.supportedArchitectures,
+        });
+    }
+    return {
+        body: {
+            id,
+            isLocal: false,
+            isInstallable: isInstallable ?? undefined,
+            latest,
+            manifest,
+            normalizedBareSpecifier,
+            resolution,
+            resolvedVia,
+            updated,
+            publishedAt,
+            alias,
+        },
+        fetching: fetchResult.fetching,
+        filesIndexFile: fetchResult.filesIndexFile,
+    };
+}
+function getFilesIndexFilePath(ctx, opts) {
+    const targetRelative = depPathToFilename(opts.pkg.id, ctx.virtualStoreDirMaxLength);
+    const target = path.join(ctx.storeDir, targetRelative);
+    if (opts.pkg.resolution.integrity) {
+        return {
+            target,
+            filesIndexFile: storeIndexKey(opts.pkg.resolution.integrity, opts.pkg.id),
+            resolution: opts.pkg.resolution,
+        };
+    }
+    let resolution;
+    if (opts.pkg.resolution.type === 'variations') {
+        resolution = findResolution(opts.pkg.resolution.variants, opts.supportedArchitectures);
+        if (resolution.integrity) {
+            return {
+                target,
+                filesIndexFile: storeIndexKey(resolution.integrity, opts.pkg.id),
+                resolution,
+            };
+        }
+    }
+    else {
+        resolution = opts.pkg.resolution;
+    }
+    const filesIndexFile = gitHostedStoreIndexKey(opts.pkg.id, { built: !opts.ignoreScripts });
+    return { filesIndexFile, target, resolution };
+}
+function findResolution(resolutionVariants, supportedArchitectures) {
+    const platform = getOneIfNonCurrent(supportedArchitectures?.os) ?? process.platform;
+    const cpu = getOneIfNonCurrent(supportedArchitectures?.cpu) ?? process.arch;
+    const libc = getOneIfNonCurrent(supportedArchitectures?.libc) ?? getLibcFamilySync();
+    const resolutionVariant = resolutionVariants
+        .find((resolutionVariant) => resolutionVariant.targets.some((target) => target.os === platform &&
+        target.cpu === cpu &&
+        (target.libc == null || target.libc === libc)));
+    if (!resolutionVariant) {
+        const resolutionTargets = resolutionVariants.map((variant) => variant.targets);
+        throw new PnpmError('NO_RESOLUTION_MATCHED', `Cannot find a resolution variant for the current platform in these resolutions: ${JSON.stringify(resolutionTargets)}`);
+    }
+    return resolutionVariant.resolution;
+}
+function getOneIfNonCurrent(requirements) {
+    if (requirements?.length && requirements[0] !== 'current') {
+        return requirements[0];
+    }
+    return undefined;
+}
+function fetchToStore(ctx, opts) {
+    if (!opts.pkg.name) {
+        opts.fetchRawManifest = true;
+    }
+    if (!ctx.fetchingLocker.has(opts.pkg.id)) {
+        const fetching = pDefer();
+        const { filesIndexFile, target, resolution } = getFilesIndexFilePath(ctx, opts);
+        doFetchToStore(filesIndexFile, fetching, target, resolution);
+        ctx.fetchingLocker.set(opts.pkg.id, {
+            fetching: removeKeyOnFail(fetching.promise),
+            filesIndexFile,
+            fetchRawManifest: opts.fetchRawManifest,
+        });
+        // When files resolves, the cached result has to set fromStore to true, without
+        // affecting previous invocations: so we need to replace the cache.
+        //
+        // Changing the value of fromStore is needed for correct reporting of `pnpm server`.
+        // Otherwise, if a package was not in store when the server started, it will always be
+        // reported as "downloaded" instead of "reused".
+        fetching.promise.then((cache) => {
+            progressLogger.debug({
+                packageId: opts.pkg.id,
+                requester: opts.lockfileDir,
+                status: cache.files.resolvedFrom === 'remote'
+                    ? 'fetched'
+                    : 'found_in_store',
+            });
+            // If it's already in the store, we don't need to update the cache
+            if (cache.files.resolvedFrom !== 'remote') {
+                return;
+            }
+            const tmp = ctx.fetchingLocker.get(opts.pkg.id);
+            // If fetching failed then it was removed from the cache.
+            // It is OK. In that case there is no need to update it.
+            if (tmp == null)
+                return;
+            ctx.fetchingLocker.set(opts.pkg.id, {
+                ...tmp,
+                fetching: Promise.resolve({
+                    ...cache,
+                    files: {
+                        ...cache.files,
+                        resolvedFrom: 'store',
+                    },
+                }),
+            });
+        })
+            .catch(() => {
+            ctx.fetchingLocker.delete(opts.pkg.id);
+        });
+    }
+    const result = ctx.fetchingLocker.get(opts.pkg.id);
+    if (opts.fetchRawManifest && !result.fetchRawManifest) {
+        result.fetching = removeKeyOnFail(result.fetching.then(async ({ files }) => {
+            if (!files.filesMap.has('package.json'))
+                return {
+                    files,
+                    bundledManifest: undefined,
+                };
+            return {
+                files,
+                bundledManifest: await readBundledManifest(files.filesMap.get('package.json')),
+            };
+        }));
+        result.fetchRawManifest = true;
+    }
+    return {
+        fetching: pShare(result.fetching),
+        filesIndexFile: result.filesIndexFile,
+    };
+    async function removeKeyOnFail(p) {
+        try {
+            return await p;
+        }
+        catch (err) { // eslint-disable-line
+            ctx.fetchingLocker.delete(opts.pkg.id);
+            if (opts.onFetchError) {
+                throw opts.onFetchError(err);
+            }
+            throw err;
+        }
+    }
+    async function doFetchToStore(filesIndexFile, fetching, target, resolution) {
+        try {
+            const isLocalTarballDep = opts.pkg.id.startsWith('file:');
+            const isLocalPkg = resolution.type === 'directory';
+            if (!opts.force &&
+                (!isLocalTarballDep ||
+                    await tarballIsUpToDate(opts.pkg.resolution, target, opts.lockfileDir) // eslint-disable-line
+                ) &&
+                !isLocalPkg) {
+                const { verified, files, bundledManifest } = await ctx.readPkgFromCafs(filesIndexFile, {
+                    readManifest: opts.fetchRawManifest,
+                    expectedPkg: opts.pkg,
+                });
+                if (verified) {
+                    fetching.resolve({
+                        files,
+                        bundledManifest,
+                    });
+                    return;
+                }
+                if ((files?.filesMap) != null) {
+                    packageRequestLogger.warn({
+                        message: `Refetching ${target} to store. It was either modified or had no integrity checksums`,
+                        prefix: opts.lockfileDir,
+                    });
+                }
+            }
+            // We fetch into targetStage directory first and then fs.rename() it to the
+            // target directory.
+            // Tarballs are requested first because they are bigger than metadata files.
+            // However, when one line is left available, allow it to be picked up by a metadata request.
+            // This is done in order to avoid situations when tarballs are downloaded in chunks
+            // As many tarballs should be downloaded simultaneously as possible.
+            const priority = (++ctx.requestsQueue.counter % ctx.requestsQueue.concurrency === 0 ? -1 : 1) * 1000;
+            const fetchedPackage = await ctx.requestsQueue.add(async () => ctx.fetch(opts.pkg.id, resolution, {
+                allowBuild: opts.allowBuild,
+                filesIndexFile,
+                lockfileDir: opts.lockfileDir,
+                readManifest: opts.fetchRawManifest,
+                onProgress: (downloaded) => {
+                    fetchingProgressLogger.debug({
+                        downloaded,
+                        packageId: opts.pkg.id,
+                        status: 'in_progress',
+                    });
+                },
+                onStart: (size, attempt) => {
+                    fetchingProgressLogger.debug({
+                        attempt,
+                        packageId: opts.pkg.id,
+                        size,
+                        status: 'started',
+                    });
+                },
+                pkg: {
+                    name: opts.pkg.name,
+                    version: opts.pkg.version,
+                },
+            }), { priority });
+            const integrity = opts.pkg.resolution.integrity ?? fetchedPackage.integrity;
+            if (isLocalTarballDep && integrity) {
+                await fs.mkdir(target, { recursive: true });
+                await gfs.writeFile(path.join(target, TARBALL_INTEGRITY_FILENAME), integrity, 'utf8');
+            }
+            fetching.resolve({
+                files: {
+                    resolvedFrom: fetchedPackage.local ? 'local-dir' : 'remote',
+                    filesMap: fetchedPackage.filesMap,
+                    packageImportMethod: fetchedPackage.packageImportMethod,
+                    requiresBuild: fetchedPackage.requiresBuild,
+                },
+                bundledManifest: fetchedPackage.manifest,
+                integrity,
+            });
+        }
+        catch (err) { // eslint-disable-line
+            fetching.reject(err);
+        }
+    }
+}
+async function readBundledManifest(pkgJsonPath) {
+    return normalizeBundledManifest(await loadJsonFile(pkgJsonPath));
+}
+async function tarballIsUpToDate(resolution, pkgInStoreLocation, lockfileDir) {
+    let currentIntegrity;
+    try {
+        currentIntegrity = (await gfs.readFile(path.join(pkgInStoreLocation, TARBALL_INTEGRITY_FILENAME), 'utf8'));
+    }
+    catch (err) { // eslint-disable-line
+        return false;
+    }
+    if (resolution.integrity && currentIntegrity !== resolution.integrity)
+        return false;
+    const tarball = path.join(lockfileDir, resolution.tarball.slice(5));
+    const tarballStream = createReadStream(tarball);
+    try {
+        return Boolean(await ssri.checkStream(tarballStream, currentIntegrity));
+    }
+    catch (err) { // eslint-disable-line
+        return false;
+    }
+}
+async function fetcher(fetcherByHostingType, cafs, customFetchers, packageId, resolution, opts) {
+    try {
+        // pickFetcher now handles custom fetcher hooks internally
+        const fetch = await pickFetcher(fetcherByHostingType, resolution, {
+            customFetchers,
+            packageId,
+        });
+        const result = await fetch(cafs, resolution, opts); // eslint-disable-line @typescript-eslint/no-explicit-any
+        return result;
+    }
+    catch (err) { // eslint-disable-line
+        packageRequestLogger.warn({
+            message: `Fetching ${packageId} failed!`,
+            prefix: opts.lockfileDir,
+        });
+        throw err;
+    }
+}
+//# sourceMappingURL=packageRequester.js.map

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@pnpm/installing.package-requester",
+  "version": "1008.0.0",
+  "description": "Concurrent downloader of npm-compatible packages",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "npm",
+    "resolver"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/installing/package-requester",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/installing/package-requester#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "detect-libc": "^2.0.3",
+    "load-json-file": "^7.0.1",
+    "p-defer": "^4.0.1",
+    "p-limit": "^7.1.0",
+    "p-queue": "^8.1.0",
+    "promise-share": "^2.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "semver": "^7.7.2",
+    "ssri": "13.0.0",
+    "@pnpm/config.package-is-installable": "1000.0.15",
+    "@pnpm/deps.path": "1001.1.3",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/fetching.fetcher-base": "1001.0.2",
+    "@pnpm/fetching.pick-fetcher": "1001.0.0",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/fs.graceful-fs": "1000.0.1",
+    "@pnpm/hooks.types": "1001.0.12",
+    "@pnpm/store.cafs": "1000.0.19",
+    "@pnpm/resolving.resolver-base": "1005.1.0",
+    "@pnpm/store.index": "1000.0.0-0",
+    "@pnpm/store.controller-types": "1004.1.0",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0",
+    "@pnpm/worker": "^1000.3.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@pnpm/registry-mock": "5.2.4",
+    "@types/normalize-path": "^3.0.2",
+    "@types/ramda": "0.29.12",
+    "@types/semver": "7.7.1",
+    "@types/ssri": "^7.1.5",
+    "delay": "^6.0.0",
+    "nock": "13.3.4",
+    "normalize-path": "^3.0.0",
+    "tempy": "3.0.0",
+    "@pnpm/fs.msgpack-file": "1100.0.0-0",
+    "@pnpm/installing.client": "1001.1.4",
+    "@pnpm/installing.package-requester": "1008.0.0",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/store.cafs-types": "1000.0.0",
+    "@pnpm/store.create-cafs-store": "1000.0.20",
+    "@pnpm/test-fixtures": "1000.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config/with-registry"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}