@pnpm/deps.inspection.commands 1000.0.0 → 1100.0.0

package/lib/index.d.ts

@@ -1,2 +1,4 @@
 export { list, ll, why } from './listing/index.js';
 export { outdated } from './outdated/index.js';
+export * as peers from './peers.js';
+export * as view from './view/index.js';

package/lib/index.js

@@ -1,3 +1,5 @@
 export { list, ll, why } from './listing/index.js';
 export { outdated } from './outdated/index.js';
+export * as peers from './peers.js';
+export * as view from './view/index.js';
 //# sourceMappingURL=index.js.map

package/lib/listing/list.d.ts

@@ -1,4 +1,4 @@
-import { type Config } from '@pnpm/config.reader';
+import { type Config, type ConfigContext } from '@pnpm/config.reader';
 import type { Finder, IncludedDependencies } from '@pnpm/types';
 export declare const EXCLUDE_PEERS_HELP: {
     description: string;
@@ -8,8 +8,9 @@ export declare function rcOptionsTypes(): Record<string, unknown>;
 export declare const cliOptionsTypes: () => Record<string, unknown>;
 export { shorthands } from './common.js';
 export declare const commandNames: string[];
+export declare const recursiveByDefault = true;
 export declare function help(): string;
-export type ListCommandOptions = Pick<Config, 'allProjects' | 'dev' | 'dir' | 'finders' | 'optional' | 'production' | 'selectedProjectsGraph' | 'modulesDir' | 'virtualStoreDirMaxLength'> & Partial<Pick<Config, 'cliOptions'>> & {
+export type ListCommandOptions = Pick<Config, 'dev' | 'dir' | 'optional' | 'production' | 'modulesDir' | 'virtualStoreDirMaxLength'> & Pick<ConfigContext, 'allProjects' | 'finders' | 'selectedProjectsGraph'> & Partial<Pick<ConfigContext, 'cliOptions'>> & {
     alwaysPrintRootPackage?: boolean;
     depth?: number;
     excludePeers?: boolean;

package/lib/listing/list.js

@@ -27,6 +27,7 @@ export const cliOptionsTypes = () => ({
 });
 export { shorthands } from './common.js';
 export const commandNames = ['list', 'ls'];
+export const recursiveByDefault = true;
 export function help() {
     return renderHelp({
         aliases: ['list', 'ls', 'la', 'll'],

package/lib/listing/ll.d.ts

@@ -1,5 +1,6 @@
 import * as list from './list.js';
 export declare const commandNames: string[];
+export declare const recursiveByDefault = true;
 export declare const rcOptionsTypes: typeof list.rcOptionsTypes;
 export declare function cliOptionsTypes(): Record<string, unknown>;
 export declare const help: typeof list.help;

package/lib/listing/ll.js

@@ -1,6 +1,7 @@
 import { omit } from 'ramda';
 import * as list from './list.js';
 export const commandNames = ['ll', 'la'];
+export const recursiveByDefault = true;
 export const rcOptionsTypes = list.rcOptionsTypes;
 export function cliOptionsTypes() {
     return omit(['long'], list.cliOptionsTypes());

package/lib/listing/why.d.ts

@@ -3,5 +3,6 @@ export declare function rcOptionsTypes(): Record<string, unknown>;
 export declare const cliOptionsTypes: () => Record<string, unknown>;
 export { shorthands } from './common.js';
 export declare const commandNames: string[];
+export declare const recursiveByDefault = true;
 export declare function help(): string;
 export declare function handler(opts: ListCommandOptions, params: string[]): Promise<string>;

package/lib/listing/why.js

@@ -18,6 +18,7 @@ export const cliOptionsTypes = () => ({
 });
 export { shorthands } from './common.js';
 export const commandNames = ['why'];
+export const recursiveByDefault = true;
 export function help() {
     return renderHelp({
         description: `Shows the packages that depend on <pkg>

package/lib/outdated/outdated.d.ts

@@ -1,5 +1,5 @@
 import type { CompletionFunc } from '@pnpm/cli.command';
-import { type Config } from '@pnpm/config.reader';
+import { type Config, type ConfigContext } from '@pnpm/config.reader';
 import { type OutdatedPackage } from '@pnpm/deps.inspection.outdated';
 import type { DependenciesField, PackageManifest } from '@pnpm/types';
 import { type OutdatedWithVersionDiff } from './utils.js';
@@ -15,7 +15,7 @@ export type OutdatedCommandOptions = {
     recursive?: boolean;
     format?: 'table' | 'list' | 'json';
     sortBy?: 'name';
-} & Pick<Config, 'allProjects' | 'ca' | 'cacheDir' | 'catalogs' | 'cert' | 'dev' | 'dir' | 'engineStrict' | 'fetchRetries' | 'fetchRetryFactor' | 'fetchRetryMaxtimeout' | 'fetchRetryMintimeout' | 'fetchTimeout' | 'global' | 'httpProxy' | 'httpsProxy' | 'key' | 'localAddress' | 'lockfileDir' | 'minimumReleaseAge' | 'minimumReleaseAgeExclude' | 'networkConcurrency' | 'noProxy' | 'offline' | 'optional' | 'production' | 'rawConfig' | 'registries' | 'selectedProjectsGraph' | 'strictSsl' | 'tag' | 'userAgent' | 'updateConfig'> & Partial<Pick<Config, 'globalPkgDir' | 'userConfig'>>;
+} & Pick<Config, 'ca' | 'cacheDir' | 'catalogs' | 'cert' | 'dev' | 'dir' | 'engineStrict' | 'fetchRetries' | 'fetchRetryFactor' | 'fetchRetryMaxtimeout' | 'fetchRetryMintimeout' | 'fetchTimeout' | 'global' | 'httpProxy' | 'httpsProxy' | 'key' | 'localAddress' | 'lockfileDir' | 'minimumReleaseAge' | 'minimumReleaseAgeExclude' | 'networkConcurrency' | 'noProxy' | 'offline' | 'optional' | 'production' | 'configByUri' | 'registries' | 'strictSsl' | 'tag' | 'userAgent' | 'updateConfig'> & Pick<ConfigContext, 'allProjects' | 'selectedProjectsGraph'> & Partial<Pick<Config, 'globalPkgDir' | 'userConfig'>>;
 export declare function handler(opts: OutdatedCommandOptions, params?: string[]): Promise<{
     output: string;
     exitCode: number;

package/lib/peers.d.ts

@@ -0,0 +1,17 @@
+import { type Config, type ConfigContext } from '@pnpm/config.reader';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare const cliOptionsTypes: () => Record<string, unknown>;
+export declare const shorthands: {};
+export declare const commandNames: string[];
+export declare const recursiveByDefault = true;
+export declare function help(): string;
+export type PeersCommandOptions = Pick<Config, 'dir' | 'modulesDir' | 'peerDependencyRules'> & Pick<ConfigContext, 'selectedProjectsGraph'> & Partial<Pick<ConfigContext, 'cliOptions'>> & {
+    json?: boolean;
+    lockfileDir?: string;
+    lockfileOnly?: boolean;
+    recursive?: boolean;
+};
+export declare function handler(opts: PeersCommandOptions, params: string[]): Promise<string | {
+    output: string;
+    exitCode: number;
+}>;

package/lib/peers.js

@@ -0,0 +1,145 @@
+import { FILTERING, UNIVERSAL_OPTIONS } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as allTypes } from '@pnpm/config.reader';
+import { checkPeerDependencies } from '@pnpm/deps.inspection.peers-checker';
+import chalk from 'chalk';
+import { isEmpty, pick } from 'ramda';
+import { renderHelp } from 'render-help';
+export function rcOptionsTypes() {
+    return pick([
+        'json',
+        'lockfile-only',
+    ], allTypes);
+}
+export const cliOptionsTypes = () => ({
+    ...rcOptionsTypes(),
+    recursive: Boolean,
+});
+export const shorthands = {};
+export const commandNames = ['peers'];
+export const recursiveByDefault = true;
+export function help() {
+    return renderHelp({
+        description: 'Commands for inspecting peer dependency relationships.',
+        descriptionLists: [
+            {
+                title: 'Commands',
+                list: [
+                    {
+                        description: 'Checks for unmet or missing peer dependency issues by reading the lockfile. \
+Exits with a non-zero exit code when issues are found.',
+                        name: 'check',
+                    },
+                ],
+            },
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Show information in JSON format',
+                        name: '--json',
+                    },
+                    {
+                        description: 'Check the lockfile only, without reading node_modules.',
+                        name: '--lockfile-only',
+                    },
+                    ...UNIVERSAL_OPTIONS,
+                ],
+            },
+            FILTERING,
+        ],
+        url: docsUrl('peers'),
+        usages: [
+            'pnpm peers <command>',
+        ],
+    });
+}
+export async function handler(opts, params) {
+    switch (params[0]) {
+        case 'check':
+        case undefined:
+            return checkCmd(opts);
+        default:
+            return { output: help(), exitCode: 1 };
+    }
+}
+async function checkCmd(opts) {
+    const lockfileDir = opts.lockfileDir ?? opts.dir;
+    const projectPaths = opts.recursive && opts.selectedProjectsGraph
+        ? Object.keys(opts.selectedProjectsGraph)
+        : [opts.dir];
+    const issues = await checkPeerDependencies(projectPaths, {
+        lockfileDir,
+        checkWantedLockfileOnly: opts.lockfileOnly,
+        modulesDir: opts.modulesDir,
+        peerDependencyRules: opts.peerDependencyRules,
+    });
+    const noIssues = hasNoIssues(issues);
+    const json = opts.json ?? opts.cliOptions?.['json'];
+    if (json) {
+        return {
+            output: JSON.stringify(issues, null, 2),
+            exitCode: noIssues ? 0 : 1,
+        };
+    }
+    if (noIssues) {
+        return { output: 'No peer dependency issues found', exitCode: 0 };
+    }
+    return {
+        output: renderPeerIssuesFlat(issues),
+        exitCode: 1,
+    };
+}
+function hasNoIssues(issues) {
+    return Object.values(issues).every((projectIssues) => isEmpty(projectIssues.bad) &&
+        isEmpty(projectIssues.missing));
+}
+function renderPeerIssuesFlat(issuesByProjects) {
+    const sections = [];
+    for (const [, { bad, missing, conflicts, intersections }] of Object.entries(issuesByProjects)) {
+        for (const [peerName, issues] of Object.entries(bad)) {
+            const foundVersion = issues[0].foundVersion;
+            const header = `${chalk.yellowBright('✕ unmet peer')} ${chalk.bold(peerName)}`;
+            const installed = `  ${chalk.cyan('Installed:')} ${chalk.dim(foundVersion)}`;
+            sections.push(`${header}\n${installed}\n${formatRequiredBy(issues)}`);
+        }
+        for (const [peerName, issues] of Object.entries(missing)) {
+            if (!intersections[peerName] && !conflicts.includes(peerName))
+                continue;
+            const conflict = conflicts.includes(peerName);
+            const header = conflict
+                ? `${chalk.red('✕ conflicting peer')} ${chalk.bold(peerName)}`
+                : `${chalk.red('✕ missing peer')} ${chalk.bold(peerName)}`;
+            sections.push(`${header}\n${formatRequiredBy(issues)}`);
+        }
+    }
+    if (sections.length === 0)
+        return '';
+    return `Issues with peer dependencies found\n\n${sections.join('\n\n')}`;
+}
+function formatRequiredBy(issues) {
+    const byRange = new Map();
+    for (const issue of issues) {
+        const declaring = issue.parents[issue.parents.length - 1];
+        const pkg = `${declaring.name}@${declaring.version}`;
+        if (!byRange.has(issue.wantedRange)) {
+            byRange.set(issue.wantedRange, new Set());
+        }
+        byRange.get(issue.wantedRange).add(pkg);
+    }
+    const lines = [`  ${chalk.cyan('Wanted:')}`];
+    for (const [range, pkgs] of byRange) {
+        lines.push(`    ${chalk.cyanBright(formatRange(range))}${chalk.cyan(':')}`);
+        for (const pkg of pkgs) {
+            lines.push(`      ${chalk.dim(pkg)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatRange(range) {
+    if (range.includes(' ') || range === '*') {
+        return `"${range}"`;
+    }
+    return range;
+}
+//# sourceMappingURL=peers.js.map

package/lib/view/index.d.ts

@@ -0,0 +1,8 @@
+import { type Config, type ConfigContext } from '@pnpm/config.reader';
+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 declare function handler(opts: Config & ConfigContext & {
+    json?: boolean;
+}, params: string[]): Promise<string | void>;

package/lib/view/index.js

@@ -0,0 +1,229 @@
+import { pickRegistryForPackage } from '@pnpm/config.pick-registry-for-package';
+import { types as allTypes } from '@pnpm/config.reader';
+import { PnpmError } from '@pnpm/error';
+import { createGetAuthHeaderByURI } from '@pnpm/network.auth-header';
+import { createFetchFromRegistry } from '@pnpm/network.fetch';
+import npa from '@pnpm/npm-package-arg';
+import { fetchMetadataFromFromRegistry, pickPackageFromMeta, pickVersionByVersionRange, } from '@pnpm/resolving.npm-resolver';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+export function rcOptionsTypes() {
+    return pick(['registry'], allTypes);
+}
+export function cliOptionsTypes() {
+    return {
+        ...rcOptionsTypes(),
+        json: Boolean,
+    };
+}
+export const commandNames = ['view', 'info', 'show', 'v'];
+export function help() {
+    return renderHelp({
+        description: 'View package information from the registry without using npm CLI.',
+        usages: [
+            'pnpm view <package-name>',
+            'pnpm view <package-name>@<version>',
+            'pnpm view <package-name> [<field>[.subfield]...]',
+        ],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Show information in JSON format',
+                        name: '--json',
+                    },
+                ],
+            },
+        ],
+    });
+}
+export async function handler(opts, params) {
+    const packageSpec = params[0];
+    if (!packageSpec) {
+        throw new PnpmError('MISSING_PACKAGE_NAME', 'Package name is required. Usage: pnpm view <package-name>');
+    }
+    const fields = params.slice(1);
+    let parsed;
+    try {
+        parsed = npa(packageSpec);
+    }
+    catch {
+        throw new PnpmError('INVALID_PACKAGE_NAME', `Invalid package name: "${packageSpec}"`);
+    }
+    if (!parsed.registry) {
+        throw new PnpmError('INVALID_PACKAGE_NAME', `Invalid package name: "${packageSpec}". pnpm view only supports registry packages.`);
+    }
+    const subSpec = parsed.type === 'alias' ? parsed.subSpec : parsed;
+    const packageName = subSpec?.name;
+    if (!packageName) {
+        throw new PnpmError('INVALID_PACKAGE_NAME', `Invalid package name: "${packageSpec}"`);
+    }
+    const specType = (subSpec?.type ?? 'tag');
+    const spec = {
+        name: packageName,
+        fetchSpec: subSpec?.fetchSpec ?? 'latest',
+        type: specType,
+    };
+    const registry = pickRegistryForPackage(opts.registries, packageName);
+    const fetchFromRegistry = createFetchFromRegistry(opts);
+    const getAuthHeader = createGetAuthHeaderByURI(opts.configByUri ?? {}, opts.registries?.default);
+    const fetchResult = await fetchMetadataFromFromRegistry({
+        fetch: fetchFromRegistry,
+        retry: {
+            factor: opts.fetchRetryFactor,
+            maxTimeout: opts.fetchRetryMaxtimeout,
+            minTimeout: opts.fetchRetryMintimeout,
+            retries: opts.fetchRetries,
+        },
+        timeout: opts.fetchTimeout ?? 60000,
+        fetchWarnTimeoutMs: 10000,
+    }, packageName, {
+        registry,
+        authHeaderValue: getAuthHeader(registry),
+        fullMetadata: true,
+    });
+    if (fetchResult.notModified) {
+        throw new PnpmError('UNEXPECTED_304', `Unexpected 304 response for ${packageName}`);
+    }
+    const { meta: metadata } = fetchResult;
+    const data = pickPackageFromMeta(pickVersionByVersionRange, { preferredVersionSelectors: undefined }, spec, metadata);
+    if (!data) {
+        throw new PnpmError('PACKAGE_NOT_FOUND', `No matching version found for ${packageName}@${spec.fetchSpec}`);
+    }
+    const versions = metadata.versions ? Object.keys(metadata.versions) : [];
+    const depsCount = data.dependencies ? Object.keys(data.dependencies).length : 0;
+    const distTags = metadata['dist-tags'];
+    const info = {
+        ...data,
+        author: typeof data.author === 'object' ? data.author.name : data.author,
+        repository: typeof data.repository === 'object' ? data.repository.url : data.repository,
+        versions,
+        versionsCount: versions.length > 0 ? versions.length : undefined,
+        depsCount: depsCount > 0 ? depsCount : undefined,
+        distTags,
+        'dist-tags': distTags,
+        time: metadata.time,
+    };
+    // If fields are specified, filter and return only those
+    if (fields.length > 0) {
+        const selectedFields = {};
+        for (const field of fields) {
+            selectedFields[field] = getNestedProperty(info, field);
+        }
+        if (opts.json) {
+            if (fields.length === 1) {
+                return JSON.stringify(selectedFields[fields[0]], null, 2);
+            }
+            return JSON.stringify(selectedFields, null, 2);
+        }
+        if (fields.length === 1) {
+            const value = selectedFields[fields[0]];
+            return formatFieldValue(value);
+        }
+        const lines = fields.map(field => {
+            const value = selectedFields[field];
+            if (typeof value === 'object' && value !== null) {
+                return `${field} = ${JSON.stringify(value)}`;
+            }
+            if (typeof value === 'string') {
+                return `${field} = '${value}'`;
+            }
+            return `${field} = ${formatFieldValue(value)}`;
+        });
+        return lines.join('\n');
+    }
+    if (opts.json) {
+        return JSON.stringify(info, null, 2);
+    }
+    const headerParts = [];
+    if (info.name && info.version) {
+        headerParts.push(`${info.name}@${info.version}`);
+    }
+    if (info.license) {
+        headerParts.push(info.license);
+    }
+    if (info.depsCount !== undefined) {
+        headerParts.push(`deps: ${info.depsCount}`);
+    }
+    else {
+        headerParts.push('deps: none');
+    }
+    if (info.versionsCount !== undefined) {
+        headerParts.push(`versions: ${info.versionsCount}`);
+    }
+    const lines = [headerParts.join(' | ')];
+    if (info.description) {
+        lines.push(info.description);
+    }
+    if (info.homepage) {
+        lines.push(info.homepage);
+    }
+    if (info.keywords && info.keywords.length > 0) {
+        lines.push('');
+        lines.push(`keywords: ${info.keywords.join(', ')}`);
+    }
+    if (info.dependencies && Object.keys(info.dependencies).length > 0) {
+        lines.push('');
+        lines.push('dependencies:');
+        const depEntries = Object.entries(info.dependencies).map(([name, version]) => `${name}: ${version}`);
+        lines.push(depEntries.join(', '));
+    }
+    if (info.dist) {
+        lines.push('');
+        lines.push('dist');
+        if (info.dist.tarball) {
+            lines.push(`.tarball: ${info.dist.tarball}`);
+        }
+        if (info.dist.shasum) {
+            lines.push(`.shasum: ${info.dist.shasum}`);
+        }
+        if (info.dist.integrity) {
+            lines.push(`.integrity: ${info.dist.integrity}`);
+        }
+        if (info.dist.unpackedSize != null) {
+            lines.push(`.unpackedSize: ${formatBytes(info.dist.unpackedSize)}`);
+        }
+    }
+    if (info.maintainers && info.maintainers.length > 0) {
+        lines.push('');
+        lines.push('maintainers:');
+        for (const maintainer of info.maintainers) {
+            lines.push(`- ${maintainer.name}`);
+        }
+    }
+    if (info.distTags && Object.keys(info.distTags).length > 0) {
+        lines.push('');
+        lines.push('dist-tags:');
+        for (const [tag, tagVersion] of Object.entries(info.distTags)) {
+            lines.push(`${tag}: ${tagVersion}`);
+        }
+    }
+    return lines.join('\n');
+}
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'kB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+function getNestedProperty(obj, path) {
+    return path.split('.').reduce((acc, part) => {
+        if (typeof acc === 'object' && acc !== null) {
+            return acc[part];
+        }
+        return undefined;
+    }, obj);
+}
+function formatFieldValue(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value, null, 2);
+    }
+    return String(value);
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.inspection.commands",
-  "version": "1000.0.0",
+  "version": "1100.0.0",
   "description": "The list, ll, why, and outdated commands of pnpm",
   "keywords": [
     "pnpm",
@@ -25,44 +25,51 @@
   ],
   "dependencies": {
     "@pnpm/colorize-semver-diff": "^1.0.1",
+    "@pnpm/npm-package-arg": "^2.0.0",
     "@pnpm/semver-diff": "^1.1.0",
     "@zkochan/table": "^2.0.1",
     "chalk": "^5.6.0",
     "ramda": "npm:@pnpm/ramda@0.28.1",
     "render-help": "^2.0.0",
-    "@pnpm/cli.common-cli-options-help": "1000.0.1",
-    "@pnpm/cli.command": "1000.0.0",
-    "@pnpm/cli.utils": "1001.2.8",
-    "@pnpm/config.reader": "1004.4.2",
-    "@pnpm/deps.inspection.outdated": "1001.1.1",
-    "@pnpm/deps.inspection.list": "1000.1.3",
-    "@pnpm/error": "1000.0.5",
-    "@pnpm/config.matcher": "1000.1.0",
-    "@pnpm/global.commands": "1000.0.0-0",
-    "@pnpm/global.packages": "1000.0.0-0",
-    "@pnpm/installing.modules-yaml": "1000.3.6",
-    "@pnpm/resolving.default-resolver": "1002.2.12",
-    "@pnpm/store.path": "1000.0.5",
-    "@pnpm/types": "1000.9.0",
-    "@pnpm/lockfile.fs": "1001.1.21"
+    "@pnpm/cli.command": "1100.0.0",
+    "@pnpm/cli.common-cli-options-help": "1100.0.0",
+    "@pnpm/cli.utils": "1100.0.0",
+    "@pnpm/config.matcher": "1100.0.0",
+    "@pnpm/config.pick-registry-for-package": "1100.0.0",
+    "@pnpm/config.reader": "1100.0.0",
+    "@pnpm/deps.inspection.outdated": "1100.0.0",
+    "@pnpm/deps.inspection.peers-checker": "1100.0.0",
+    "@pnpm/error": "1100.0.0",
+    "@pnpm/global.commands": "1100.0.0",
+    "@pnpm/installing.modules-yaml": "1100.0.0",
+    "@pnpm/global.packages": "1100.0.0",
+    "@pnpm/lockfile.fs": "1100.0.0",
+    "@pnpm/network.auth-header": "1100.0.0",
+    "@pnpm/network.fetch": "1100.0.0",
+    "@pnpm/resolving.npm-resolver": "1100.0.0",
+    "@pnpm/store.path": "1100.0.0",
+    "@pnpm/deps.inspection.list": "1100.0.0",
+    "@pnpm/resolving.default-resolver": "1100.0.0",
+    "@pnpm/types": "1100.0.0"
   },
   "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",
+    "@jest/globals": "30.3.0",
+    "@pnpm/registry-mock": "6.0.0",
+    "@types/ramda": "0.31.1",
     "@types/zkochan__table": "npm:@types/table@6.0.0",
     "execa": "npm:safe-execa@0.3.0",
-    "symlink-dir": "^7.0.0",
+    "symlink-dir": "^10.0.1",
     "write-yaml-file": "^6.0.0",
-    "@pnpm/constants": "1001.3.1",
-    "@pnpm/prepare": "1000.0.4",
-    "@pnpm/installing.commands": "1004.6.10",
-    "@pnpm/test-fixtures": "1000.0.0",
-    "@pnpm/deps.inspection.commands": "1000.0.0",
-    "@pnpm/workspace.projects-filter": "1000.0.43"
+    "@pnpm/constants": "1100.0.0",
+    "@pnpm/deps.inspection.commands": "1100.0.0",
+    "@pnpm/installing.commands": "1100.0.0",
+    "@pnpm/prepare": "1100.0.0",
+    "@pnpm/test-fixtures": "1100.0.0",
+    "@pnpm/testing.command-defaults": "1100.0.0",
+    "@pnpm/workspace.projects-filter": "1100.0.0"
   },
   "engines": {
     "node": ">=22.13"
@@ -72,8 +79,8 @@
   },
   "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"
+    "test": "pn compile && pn --filter=pnpm compile && pn .test",
+    "compile": "tsgo --build && pn lint --fix",
+    ".test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
   }
 }