@pnpm/building.commands 1000.0.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/lib/build/index.d.ts

@@ -0,0 +1,3 @@
+import * as rebuild from './rebuild.js';
+export { type RebuildCommandOpts } from './rebuild.js';
+export { rebuild };

package/lib/build/index.js

@@ -0,0 +1,4 @@
+import * as rebuild from './rebuild.js';
+export {} from './rebuild.js';
+export { rebuild };
+//# sourceMappingURL=index.js.map

package/lib/build/rebuild.d.ts

@@ -0,0 +1,16 @@
+import { type Config } from '@pnpm/config.reader';
+import type { LogBase } from '@pnpm/logger';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export type RebuildCommandOpts = Pick<Config, 'allProjects' | 'dir' | 'engineStrict' | 'hooks' | 'lockfileDir' | 'nodeLinker' | 'rawLocalConfig' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'registries' | 'scriptShell' | 'selectedProjectsGraph' | 'sideEffectsCache' | 'sideEffectsCacheReadonly' | 'scriptsPrependNodePath' | 'shellEmulator' | 'workspaceDir'> & CreateStoreControllerOptions & {
+    recursive?: boolean;
+    reporter?: (logObj: LogBase) => void;
+    pending: boolean;
+    skipIfHasSideEffectsCache?: boolean;
+    neverBuiltDependencies?: string[];
+    allowBuilds?: Record<string, boolean | string>;
+};
+export declare function handler(opts: RebuildCommandOpts, params: string[]): Promise<void>;

package/lib/build/rebuild.js

@@ -0,0 +1,90 @@
+import { buildProjects, buildSelectedPkgs, } from '@pnpm/building.after-install';
+import { FILTERING, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl, readProjectManifestOnly } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { createStoreController, } from '@pnpm/store.connection-manager';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { recursiveRebuild } from './recursive.js';
+export function rcOptionsTypes() {
+    return {
+        ...pick([
+            'npm-path',
+            'reporter',
+            'scripts-prepend-node-path',
+            'unsafe-perm',
+            'store-dir',
+        ], allTypes),
+    };
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        pending: Boolean,
+        recursive: Boolean,
+    };
+}
+export const commandNames = ['rebuild', 'rb'];
+export function help() {
+    return renderHelp({
+        aliases: ['rb'],
+        description: 'Rebuild a package.',
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Rebuild every package found in subdirectories \
+or every workspace package, when executed inside a workspace. \
+For options that may be used with `-r`, see "pnpm help recursive"',
+                        name: '--recursive',
+                        shortAlias: '-r',
+                    },
+                    {
+                        description: 'Rebuild packages that were not build during installation. Packages are not build when installing with the --ignore-scripts flag',
+                        name: '--pending',
+                    },
+                    {
+                        description: 'The directory in which all the packages are saved on the disk',
+                        name: '--store-dir <dir>',
+                    },
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('rebuild'),
+        usages: ['pnpm rebuild [<pkg> ...]'],
+    });
+}
+export async function handler(opts, params) {
+    if (opts.recursive && (opts.allProjects != null) && (opts.selectedProjectsGraph != null) && opts.workspaceDir) {
+        await recursiveRebuild(opts.allProjects, params, { ...opts, selectedProjectsGraph: opts.selectedProjectsGraph, workspaceDir: opts.workspaceDir });
+        return;
+    }
+    const store = await createStoreController(opts);
+    const rebuildOpts = Object.assign(opts, {
+        sideEffectsCacheRead: opts.sideEffectsCache ?? opts.sideEffectsCacheReadonly,
+        sideEffectsCacheWrite: opts.sideEffectsCache,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+    });
+    if (params.length === 0) {
+        await buildProjects([
+            {
+                buildIndex: 0,
+                manifest: await readProjectManifestOnly(rebuildOpts.dir, opts),
+                rootDir: rebuildOpts.dir,
+            },
+        ], rebuildOpts);
+        return;
+    }
+    await buildSelectedPkgs([
+        {
+            buildIndex: 0,
+            manifest: await readProjectManifestOnly(rebuildOpts.dir, opts),
+            rootDir: rebuildOpts.dir,
+        },
+    ], params, rebuildOpts);
+}
+//# sourceMappingURL=rebuild.js.map

package/lib/build/recursive.d.ts

@@ -0,0 +1,10 @@
+import { type Config } from '@pnpm/config.reader';
+import { type CreateStoreControllerOptions } from '@pnpm/store.connection-manager';
+import type { Project } from '@pnpm/types';
+type RecursiveRebuildOpts = CreateStoreControllerOptions & Pick<Config, 'hoistPattern' | 'hooks' | 'ignorePnpmfile' | 'ignoreScripts' | 'lockfileDir' | 'lockfileOnly' | 'nodeLinker' | 'packageConfigs' | 'rawLocalConfig' | 'registries' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'sharedWorkspaceLockfile'> & {
+    pending?: boolean;
+} & Partial<Pick<Config, 'bail' | 'sort' | 'workspaceConcurrency'>>;
+export declare function recursiveRebuild(allProjects: Project[], params: string[], opts: RecursiveRebuildOpts & {
+    ignoredPackages?: Set<string>;
+} & Required<Pick<Config, 'selectedProjectsGraph' | 'workspaceDir'>>): Promise<void>;
+export {};

package/lib/build/recursive.js

@@ -0,0 +1,115 @@
+import assert from 'node:assert';
+import util from 'node:util';
+import { buildProjects as rebuildAll, buildSelectedPkgs } from '@pnpm/building.after-install';
+import { throwOnCommandFail, } from '@pnpm/cli.utils';
+import { createProjectConfigRecord, getWorkspaceConcurrency, } from '@pnpm/config.reader';
+import { logger } from '@pnpm/logger';
+import { createStoreController } from '@pnpm/store.connection-manager';
+import { sortProjects } from '@pnpm/workspace.projects-sorter';
+import pLimit from 'p-limit';
+export async function recursiveRebuild(allProjects, params, opts) {
+    if (allProjects.length === 0) {
+        // It might make sense to throw an exception in this case
+        return;
+    }
+    const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
+    if (pkgs.length === 0) {
+        return;
+    }
+    const manifestsByPath = {};
+    for (const { rootDir, manifest, writeProjectManifest } of pkgs) {
+        manifestsByPath[rootDir] = { manifest, writeProjectManifest };
+    }
+    const throwOnFail = throwOnCommandFail.bind(null, 'pnpm recursive rebuild');
+    const chunks = opts.sort !== false
+        ? sortProjects(opts.selectedProjectsGraph)
+        : [Object.keys(opts.selectedProjectsGraph).sort()];
+    const store = await createStoreController(opts);
+    const rebuildOpts = Object.assign(opts, {
+        ownLifecycleHooksStdio: 'pipe',
+        pruneLockfileImporters: ((opts.ignoredPackages == null) || opts.ignoredPackages.size === 0) &&
+            pkgs.length === allProjects.length,
+        storeController: store.ctrl,
+        storeDir: store.dir,
+    });
+    const result = {};
+    const projectConfigRecord = createProjectConfigRecord(opts) ?? {};
+    async function getImporters() {
+        const importers = [];
+        await Promise.all(chunks.map(async (prefixes, buildIndex) => {
+            if (opts.ignoredPackages != null) {
+                prefixes = prefixes.filter((prefix) => !opts.ignoredPackages.has(prefix));
+            }
+            return Promise.all(prefixes.map(async (prefix) => {
+                importers.push({
+                    buildIndex,
+                    manifest: manifestsByPath[prefix].manifest,
+                    rootDir: prefix,
+                });
+            }));
+        }));
+        return importers;
+    }
+    const rebuild = (params.length === 0
+        ? rebuildAll
+        : (importers, opts) => buildSelectedPkgs(importers, params, opts) // eslint-disable-line
+    );
+    if (opts.lockfileDir) {
+        const importers = await getImporters();
+        await rebuild(importers, {
+            ...rebuildOpts,
+            pending: opts.pending === true,
+        });
+        return;
+    }
+    const limitRebuild = pLimit(getWorkspaceConcurrency(opts.workspaceConcurrency));
+    for (const chunk of chunks) {
+        // eslint-disable-next-line no-await-in-loop
+        await Promise.all(chunk.map(async (rootDir) => limitRebuild(async () => {
+            try {
+                if (opts.ignoredPackages?.has(rootDir)) {
+                    return;
+                }
+                result[rootDir] = { status: 'running' };
+                const { manifest } = opts.selectedProjectsGraph[rootDir].package;
+                const localConfig = manifest.name ? projectConfigRecord[manifest.name] : undefined;
+                await rebuild([
+                    {
+                        buildIndex: 0,
+                        manifest: manifestsByPath[rootDir].manifest,
+                        rootDir,
+                    },
+                ], {
+                    ...rebuildOpts,
+                    ...localConfig,
+                    dir: rootDir,
+                    pending: opts.pending === true,
+                    rawConfig: {
+                        ...rebuildOpts.rawConfig,
+                        ...localConfig,
+                    },
+                });
+                result[rootDir].status = 'passed';
+            }
+            catch (err) {
+                assert(util.types.isNativeError(err));
+                const errWithPrefix = Object.assign(err, {
+                    prefix: rootDir,
+                });
+                logger.info(errWithPrefix);
+                if (!opts.bail) {
+                    result[rootDir] = {
+                        status: 'failure',
+                        error: errWithPrefix,
+                        message: err.message,
+                        prefix: rootDir,
+                    };
+                    return;
+                }
+                throw err;
+            }
+        })));
+    }
+    throwOnFail(result);
+}
+//# sourceMappingURL=recursive.js.map

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { rebuild } from './build/index.js';
+export type { RebuildCommandOpts } from './build/rebuild.js';
+export type { ApproveBuildsCommandOpts } from './policy/approveBuilds.js';
+export { approveBuilds, ignoredBuilds } from './policy/index.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { rebuild } from './build/index.js';
+export { approveBuilds, ignoredBuilds } from './policy/index.js';
+//# sourceMappingURL=index.js.map

package/lib/policy/approveBuilds.d.ts

@@ -0,0 +1,11 @@
+import { type RebuildCommandOpts } from '@pnpm/building.commands';
+import type { Config } from '@pnpm/config.reader';
+export type ApproveBuildsCommandOpts = Pick<Config, 'modulesDir' | 'dir' | 'rootProjectManifest' | 'rootProjectManifestDir' | 'allowBuilds'> & {
+    all?: boolean;
+    global?: boolean;
+};
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function handler(opts: ApproveBuildsCommandOpts & RebuildCommandOpts): Promise<void>;

package/lib/policy/approveBuilds.js

@@ -0,0 +1,140 @@
+import { rebuild } from '@pnpm/building.commands';
+import { writeSettings } from '@pnpm/config.writer';
+import { PnpmError } from '@pnpm/error';
+import { writeModulesManifest } from '@pnpm/installing.modules-yaml';
+import { globalInfo } from '@pnpm/logger';
+import { lexCompare } from '@pnpm/util.lex-comparator';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import { renderHelp } from 'render-help';
+import { getAutomaticallyIgnoredBuilds } from './getAutomaticallyIgnoredBuilds.js';
+export const commandNames = ['approve-builds'];
+export function help() {
+    return renderHelp({
+        description: 'Approve dependencies for running scripts during installation',
+        usages: [],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Approve all pending dependencies without interactive prompts',
+                        name: '--all',
+                    },
+                ],
+            },
+        ],
+    });
+}
+export function cliOptionsTypes() {
+    return {
+        all: Boolean,
+        global: Boolean,
+    };
+}
+export function rcOptionsTypes() {
+    return {};
+}
+export async function handler(opts) {
+    if (opts.global) {
+        throw new PnpmError('APPROVE_BUILDS_NOT_SUPPORTED_WITH_GLOBAL', '"approve-builds" is not supported with global packages', {
+            hint: 'Use --allow-build when installing globally, e.g. "pnpm add -g --allow-build=<pkg> <pkg>". ' +
+                'pnpm will also prompt to allow builds interactively during global install.',
+        });
+    }
+    const { automaticallyIgnoredBuilds, modulesDir, modulesManifest, } = await getAutomaticallyIgnoredBuilds(opts);
+    if (!automaticallyIgnoredBuilds?.length) {
+        globalInfo('There are no packages awaiting approval');
+        return;
+    }
+    let buildPackages = [];
+    if (opts.all) {
+        buildPackages = sortUniqueStrings([...automaticallyIgnoredBuilds]);
+    }
+    else {
+        const { result } = await enquirer.prompt({
+            choices: sortUniqueStrings([...automaticallyIgnoredBuilds]),
+            indicator(state, choice) {
+                return ` ${choice.enabled ? '●' : '○'}`;
+            },
+            message: 'Choose which packages to build ' +
+                `(Press ${chalk.cyan('<space>')} to select, ` +
+                `${chalk.cyan('<a>')} to toggle all, ` +
+                `${chalk.cyan('<i>')} to invert selection)`,
+            name: 'result',
+            pointer: '❯',
+            result() {
+                return this.selected;
+            },
+            styles: {
+                dark: chalk.reset,
+                em: chalk.bgBlack.whiteBright,
+                success: chalk.reset,
+            },
+            type: 'multiselect',
+            // For Vim users (related: https://github.com/enquirer/enquirer/pull/163)
+            j() {
+                return this.down();
+            },
+            k() {
+                return this.up();
+            },
+            cancel() {
+                // By default, canceling the prompt via Ctrl+c throws an empty string.
+                // The custom cancel function prevents that behavior.
+                // Otherwise, pnpm CLI would print an error and confuse users.
+                // See related issue: https://github.com/enquirer/enquirer/issues/225
+                process.exit(0);
+            },
+        }); // eslint-disable-line @typescript-eslint/no-explicit-any
+        buildPackages = result.map(({ value }) => value);
+    }
+    const ignoredPackages = automaticallyIgnoredBuilds.filter((automaticallyIgnoredBuild) => !buildPackages.includes(automaticallyIgnoredBuild));
+    const allowBuilds = { ...opts.allowBuilds };
+    if (ignoredPackages.length) {
+        for (const pkg of ignoredPackages) {
+            allowBuilds[pkg] = false;
+        }
+    }
+    if (buildPackages.length) {
+        for (const pkg of buildPackages) {
+            allowBuilds[pkg] = true;
+        }
+    }
+    if (!opts.all) {
+        if (buildPackages.length) {
+            const confirmed = await enquirer.prompt({
+                type: 'confirm',
+                name: 'build',
+                message: `The next packages will now be built: ${buildPackages.join(', ')}.
+Do you approve?`,
+                initial: false,
+            });
+            if (!confirmed.build) {
+                return;
+            }
+        }
+        else {
+            globalInfo('All packages were added to allowBuilds with value false.');
+        }
+    }
+    await writeSettings({
+        ...opts,
+        workspaceDir: opts.workspaceDir ?? opts.rootProjectManifestDir,
+        updatedSettings: { allowBuilds },
+    });
+    if (buildPackages.length) {
+        return rebuild.handler({
+            ...opts,
+            allowBuilds,
+        }, buildPackages);
+    }
+    else if (modulesManifest) {
+        delete modulesManifest.ignoredBuilds;
+        await writeModulesManifest(modulesDir, modulesManifest);
+    }
+}
+function sortUniqueStrings(array) {
+    return Array.from(new Set(array)).sort(lexCompare);
+}
+//# sourceMappingURL=approveBuilds.js.map

package/lib/policy/getAutomaticallyIgnoredBuilds.d.ts

@@ -0,0 +1,8 @@
+import { type Modules } from '@pnpm/installing.modules-yaml';
+import type { IgnoredBuildsCommandOpts } from './ignoredBuilds.js';
+export interface GetAutomaticallyIgnoredBuildsResult {
+    automaticallyIgnoredBuilds: string[] | null;
+    modulesDir: string;
+    modulesManifest: Modules | null;
+}
+export declare function getAutomaticallyIgnoredBuilds(opts: IgnoredBuildsCommandOpts): Promise<GetAutomaticallyIgnoredBuildsResult>;

package/lib/policy/getAutomaticallyIgnoredBuilds.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+import { parse } from '@pnpm/deps.path';
+import { readModulesManifest } from '@pnpm/installing.modules-yaml';
+export async function getAutomaticallyIgnoredBuilds(opts) {
+    const modulesDir = getModulesDir(opts);
+    const modulesManifest = await readModulesManifest(modulesDir);
+    let automaticallyIgnoredBuilds;
+    if (modulesManifest?.ignoredBuilds) {
+        const ignoredPkgNames = new Set();
+        for (const depPath of modulesManifest.ignoredBuilds) {
+            ignoredPkgNames.add(parse(depPath).name ?? depPath);
+        }
+        automaticallyIgnoredBuilds = Array.from(ignoredPkgNames);
+    }
+    else {
+        automaticallyIgnoredBuilds = null;
+    }
+    return {
+        automaticallyIgnoredBuilds,
+        modulesDir,
+        modulesManifest,
+    };
+}
+function getModulesDir(opts) {
+    return opts.modulesDir ?? path.join(opts.lockfileDir ?? opts.dir, 'node_modules');
+}
+//# sourceMappingURL=getAutomaticallyIgnoredBuilds.js.map

package/lib/policy/ignoredBuilds.d.ts

@@ -0,0 +1,7 @@
+import type { Config } from '@pnpm/config.reader';
+export type IgnoredBuildsCommandOpts = Pick<Config, 'modulesDir' | 'dir' | 'allowBuilds' | 'lockfileDir'>;
+export declare const commandNames: string[];
+export declare function help(): string;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function handler(opts: IgnoredBuildsCommandOpts): Promise<string>;

package/lib/policy/ignoredBuilds.js

@@ -0,0 +1,48 @@
+import { renderHelp } from 'render-help';
+import { getAutomaticallyIgnoredBuilds } from './getAutomaticallyIgnoredBuilds.js';
+export const commandNames = ['ignored-builds'];
+export function help() {
+    return renderHelp({
+        description: 'Print the list of packages with blocked build scripts',
+        usages: [],
+    });
+}
+export function cliOptionsTypes() {
+    return {};
+}
+export function rcOptionsTypes() {
+    return {};
+}
+export async function handler(opts) {
+    const disallowedBuilds = opts.allowBuilds
+        ? Object.entries(opts.allowBuilds)
+            .filter(([, value]) => value === false)
+            .map(([pkg]) => pkg)
+        : [];
+    let { automaticallyIgnoredBuilds } = await getAutomaticallyIgnoredBuilds(opts);
+    if (automaticallyIgnoredBuilds) {
+        automaticallyIgnoredBuilds = automaticallyIgnoredBuilds
+            .filter((automaticallyIgnoredBuild) => !disallowedBuilds.includes(automaticallyIgnoredBuild));
+    }
+    let output = 'Automatically ignored builds during installation:\n';
+    if (automaticallyIgnoredBuilds == null) {
+        output += '  Cannot identify as no node_modules found';
+    }
+    else if (automaticallyIgnoredBuilds.length === 0) {
+        output += '  None';
+    }
+    else {
+        output += `  ${automaticallyIgnoredBuilds.join('\n  ')}
+hint: To allow the execution of build scripts for a package, add its name to "allowBuilds" and set to "true", then run "pnpm rebuild".
+hint: For example:
+hint: allowBuilds:
+hint:   esbuild: true
+hint: If you don't want to build a package, set it to "false" instead.`;
+    }
+    output += '\n';
+    if (disallowedBuilds.length) {
+        output += `\nExplicitly ignored package builds (via allowBuilds):\n  ${disallowedBuilds.join('\n  ')}\n`;
+    }
+    return output;
+}
+//# sourceMappingURL=ignoredBuilds.js.map

package/lib/policy/index.d.ts

@@ -0,0 +1,4 @@
+import * as approveBuilds from './approveBuilds.js';
+import * as ignoredBuilds from './ignoredBuilds.js';
+export type { ApproveBuildsCommandOpts } from './approveBuilds.js';
+export { approveBuilds, ignoredBuilds };

package/lib/policy/index.js

@@ -0,0 +1,4 @@
+import * as approveBuilds from './approveBuilds.js';
+import * as ignoredBuilds from './ignoredBuilds.js';
+export { approveBuilds, ignoredBuilds };
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@pnpm/building.commands",
+  "version": "1000.0.0-0",
+  "description": "Commands for rebuilding and managing dependency builds",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "rebuild"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/building/commands",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/building/commands#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": {
+    "@pnpm/util.lex-comparator": "^3.0.2",
+    "chalk": "^5.6.0",
+    "enquirer": "^2.4.1",
+    "p-limit": "^7.1.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "render-help": "^2.0.0",
+    "@pnpm/building.after-install": "1000.0.0-0",
+    "@pnpm/cli.common-cli-options-help": "1000.0.1",
+    "@pnpm/config.writer": "1000.0.14",
+    "@pnpm/config.reader": "1004.4.2",
+    "@pnpm/deps.path": "1001.1.3",
+    "@pnpm/prepare-temp-dir": "1000.0.0",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/installing.modules-yaml": "1000.3.6",
+    "@pnpm/cli.utils": "1001.2.8",
+    "@pnpm/store.connection-manager": "1002.2.4",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/workspace.projects-sorter": "1000.0.11"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@pnpm/registry-mock": "5.2.4",
+    "@types/ramda": "0.29.12",
+    "execa": "npm:safe-execa@0.3.0",
+    "load-json-file": "^7.0.1",
+    "read-yaml-file": "^3.0.0",
+    "write-package": "7.2.0",
+    "write-yaml-file": "^6.0.0",
+    "@pnpm/assert-project": "1000.0.4",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/building.commands": "1000.0.0-0",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/prepare": "1000.0.4",
+    "@pnpm/store.cafs": "1000.0.19",
+    "@pnpm/crypto.object-hasher": "1000.1.0",
+    "@pnpm/store.index": "1000.0.0-0",
+    "@pnpm/test-ipc-server": "1000.0.0",
+    "@pnpm/test-fixtures": "1000.0.0",
+    "@pnpm/workspace.projects-filter": "1000.0.43"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config/with-registry"
+  },
+  "scripts": {
+    "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"
+  }
+}