@pnpm/cli.default-reporter 1100.3.11 → 1100.3.13

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @pnpm/default-reporter
 
+## 1100.3.13
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/cli.meta@1100.0.12
+  - @pnpm/config.reader@1101.15.0
+  - @pnpm/core-loggers@1100.3.0
+  - @pnpm/deps.inspection.peers-issues-renderer@1100.0.10
+  - @pnpm/installing.dedupe.issues-renderer@1100.0.3
+  - @pnpm/types@1101.7.0
+
+## 1100.3.12
+
+### Patch Changes
+
+- Republished every package: the tarballs published by the v11.13.1 through v11.16.0 releases were missing most of their compiled files due to a packing bug [#13164](https://github.com/pnpm/pnpm/issues/13164).
+
+- Updated dependencies:
+  - @pnpm/cli.meta@1100.0.11
+  - @pnpm/config.reader@1101.14.0
+  - @pnpm/core-loggers@1100.2.5
+  - @pnpm/deps.inspection.peers-issues-renderer@1100.0.9
+  - @pnpm/error@1100.1.0
+  - @pnpm/installing.dedupe.issues-renderer@1100.0.2
+  - @pnpm/installing.dedupe.types@1100.0.2
+  - @pnpm/types@1101.6.0
+
 ## 1100.3.11
 
 ### Patch Changes

package/lib/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(argv: readonly string[]): Promise<void>;

package/lib/cli.js

@@ -0,0 +1,50 @@
+import { EventEmitter } from 'node:events';
+import readline from 'node:readline';
+import { initDefaultReporter } from './index.js';
+export async function runCli(argv) {
+    const cmd = argv[0] ?? 'install';
+    const emitter = new EventEmitter();
+    const streamParser = {
+        on: (event, reporter) => {
+            emitter.on(event, reporter);
+        },
+        removeListener: (event, reporter) => {
+            emitter.removeListener(event, reporter);
+        },
+    };
+    const close = initDefaultReporter({
+        streamParser,
+        context: { argv: [cmd] },
+        reportingOptions: {
+            throttleProgress: 200,
+        },
+    });
+    // initDefaultReporter registers its 'data' listener via setTimeout(0); wait
+    // a tick so events emitted from the readline loop below aren't dropped.
+    await new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+    try {
+        const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            // Guard against valid JSON that isn't a log object (e.g. `null`,
+            // numbers, strings) — the reporter dispatches on `log.name`.
+            if (parsed == null || typeof parsed !== 'object')
+                continue;
+            emitter.emit('data', parsed);
+        }
+    }
+    finally {
+        close();
+    }
+}
+//# sourceMappingURL=cli.js.map

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const EOL = "\n";

package/lib/constants.js

@@ -0,0 +1,4 @@
+// In terminals, always Unix line endings are used
+// even on Windows
+export const EOL = '\n';
+//# sourceMappingURL=constants.js.map

package/lib/index.d.ts

@@ -0,0 +1,54 @@
+import type { Config, ConfigContext } from '@pnpm/config.reader';
+import type * as logs from '@pnpm/core-loggers';
+import type { LogLevel, StreamParser } from '@pnpm/logger';
+import * as Rx from 'rxjs';
+import type { FilterPkgsDiff } from './reporterForClient/reportSummary.js';
+import { formatWarn } from './reporterForClient/utils/formatWarn.js';
+export { formatWarn };
+export declare function initDefaultReporter(opts: {
+    useStderr?: boolean;
+    streamParser: StreamParser<logs.Log>;
+    reportingOptions?: {
+        appendOnly?: boolean;
+        logLevel?: LogLevel;
+        streamLifecycleOutput?: boolean;
+        aggregateOutput?: boolean;
+        throttleProgress?: number;
+        outputMaxWidth?: number;
+        hideAddedPkgsProgress?: boolean;
+        hideProgressPrefix?: boolean;
+        hideLifecycleOutput?: boolean;
+        hideLifecyclePrefix?: boolean;
+        approveBuildsInstructionText?: string;
+    };
+    context: {
+        argv: string[];
+        config?: Config & ConfigContext;
+        env?: NodeJS.ProcessEnv;
+        process?: NodeJS.Process;
+    };
+    filterPkgsDiff?: FilterPkgsDiff;
+}): () => void;
+export declare function toOutput$(opts: {
+    streamParser: StreamParser<logs.Log>;
+    reportingOptions?: {
+        appendOnly?: boolean;
+        logLevel?: LogLevel;
+        outputMaxWidth?: number;
+        streamLifecycleOutput?: boolean;
+        aggregateOutput?: boolean;
+        throttleProgress?: number;
+        hideAddedPkgsProgress?: boolean;
+        hideProgressPrefix?: boolean;
+        hideLifecycleOutput?: boolean;
+        hideLifecyclePrefix?: boolean;
+        approveBuildsInstructionText?: string;
+    };
+    context: {
+        argv: string[];
+        config?: Config & ConfigContext;
+        env?: NodeJS.ProcessEnv;
+        process?: NodeJS.Process;
+    };
+    filterPkgsDiff?: FilterPkgsDiff;
+}): Rx.Observable<string>;

package/lib/mergeOutputs.d.ts

@@ -0,0 +1,4 @@
+import * as Rx from 'rxjs';
+export declare function mergeOutputs(outputs: Array<Rx.Observable<Rx.Observable<{
+    msg: string;
+}>>>): Rx.Observable<string>;

package/lib/mergeOutputs.js

@@ -0,0 +1,69 @@
+import * as Rx from 'rxjs';
+import { filter, map, mergeAll, scan } from 'rxjs/operators';
+import { EOL } from './constants.js';
+export function mergeOutputs(outputs) {
+    let blockNo = 0;
+    let fixedBlockNo = 0;
+    let started = false;
+    let previousOutput = null;
+    return Rx.merge(...outputs).pipe(map((log) => {
+        let currentBlockNo = -1;
+        let currentFixedBlockNo = -1;
+        return log.pipe(map((msg) => {
+            if (msg.fixed) {
+                if (currentFixedBlockNo === -1) {
+                    currentFixedBlockNo = fixedBlockNo++;
+                }
+                return {
+                    blockNo: currentFixedBlockNo,
+                    fixed: true,
+                    msg: msg.msg,
+                };
+            }
+            if (currentBlockNo === -1) {
+                currentBlockNo = blockNo++;
+            }
+            return {
+                blockNo: currentBlockNo,
+                fixed: false,
+                msg: typeof msg === 'string' ? msg : msg.msg, // eslint-disable-line
+                prevFixedBlockNo: currentFixedBlockNo,
+            };
+        }));
+    }), mergeAll(), scan((acc, log) => {
+        if (log.fixed) {
+            acc.fixedBlocks[log.blockNo] = log.msg;
+        }
+        else {
+            delete acc.fixedBlocks[log.prevFixedBlockNo];
+            acc.blocks[log.blockNo] = log.msg;
+        }
+        return acc;
+    }, { fixedBlocks: [], blocks: [] }), map((sections) => {
+        const fixedBlocks = sections.fixedBlocks.filter(Boolean);
+        const nonFixedPart = sections.blocks.filter(Boolean).join(EOL);
+        if (fixedBlocks.length === 0) {
+            return nonFixedPart;
+        }
+        const fixedPart = fixedBlocks.join(EOL);
+        if (!nonFixedPart) {
+            return fixedPart;
+        }
+        return `${nonFixedPart}${EOL}${fixedPart}`;
+    }), filter((msg) => {
+        if (started) {
+            return true;
+        }
+        if (msg === '')
+            return false;
+        started = true;
+        return true;
+    }), filter((msg) => {
+        if (msg !== previousOutput) {
+            previousOutput = msg;
+            return true;
+        }
+        return false;
+    }));
+}
+//# sourceMappingURL=mergeOutputs.js.map

package/lib/reportError.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from '@pnpm/config.reader';
+import type { Log } from '@pnpm/core-loggers';
+export declare function reportError(logObj: Log, config?: Config): string | null;

package/lib/reportError.js

@@ -0,0 +1,426 @@
+import { renderPeerIssues } from '@pnpm/deps.inspection.peers-issues-renderer';
+import { renderDedupeCheckIssues } from '@pnpm/installing.dedupe.issues-renderer';
+import chalk from 'chalk';
+import { equals } from 'ramda';
+import StackTracey from 'stacktracey';
+import { EOL } from './constants.js';
+StackTracey.maxColumnWidths = {
+    callee: 25,
+    file: 350,
+    sourceLine: 25,
+};
+const highlight = chalk.yellow;
+const colorPath = chalk.gray;
+export function reportError(logObj, config) {
+    const errorInfo = getErrorInfo(logObj, config);
+    if (!errorInfo)
+        return null;
+    let output = formatErrorSummary(errorInfo.title, logObj.err?.code);
+    if (logObj.pkgsStack != null) {
+        if (logObj.pkgsStack.length > 0) {
+            output += `\n\n${formatPkgsStack(logObj.pkgsStack)}`;
+        }
+        else if ('prefix' in logObj && logObj.prefix) {
+            output += `\n\nThis error happened while installing a direct dependency of ${logObj.prefix}`;
+        }
+    }
+    if (errorInfo.body) {
+        output += `\n\n${errorInfo.body}`;
+    }
+    return output;
+}
+function getErrorInfo(logObj, config) {
+    if ('err' in logObj && logObj.err) {
+        const err = logObj.err;
+        switch (err.code) {
+            case 'ERR_PNPM_UNEXPECTED_STORE':
+                return reportUnexpectedStore(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_UNEXPECTED_VIRTUAL_STORE':
+                return reportUnexpectedVirtualStoreDir(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_STORE_BREAKING_CHANGE':
+                return reportStoreBreakingChange(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_MODULES_BREAKING_CHANGE':
+                return reportModulesBreakingChange(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_MODIFIED_DEPENDENCY':
+                return reportModifiedDependency(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_LOCKFILE_BREAKING_CHANGE':
+                return reportLockfileBreakingChange(err, logObj);
+            case 'ERR_PNPM_RECURSIVE_RUN_NO_SCRIPT':
+                return { title: err.message };
+            case 'ERR_PNPM_MISSING_TIME':
+                return { title: err.message, body: 'If you cannot fix this registry issue, then set "resolution-mode" to "highest".' };
+            case 'ERR_PNPM_NO_MATCHING_VERSION':
+            case 'ERR_PNPM_NO_MATURE_MATCHING_VERSION':
+                // ERR_PNPM_NO_MATURE_MATCHING_VERSION used to come from the resolver
+                // with `packageMeta` attached; it now comes from the install / dlx /
+                // self-update callers as a plain PnpmError once the resolver has
+                // surfaced the violations. `packageMeta` may be undefined, in which
+                // case the formatter falls back to the bare title+message.
+                return formatNoMatchingVersion(err, logObj);
+            case 'ERR_PNPM_RECURSIVE_FAIL':
+                return formatRecursiveCommandSummary(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_BAD_TARBALL_SIZE':
+                return reportBadTarballSize(err, logObj);
+            case 'ELIFECYCLE':
+                return reportLifecycleError(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_UNSUPPORTED_ENGINE':
+                return reportEngineError(logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_PEER_DEP_ISSUES':
+                return reportPeerDependencyIssuesError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_DEDUPE_CHECK_ISSUES':
+                return reportDedupeCheckIssuesError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_SPEC_NOT_SUPPORTED_BY_ANY_RESOLVER':
+                return reportSpecNotSupportedByAnyResolverError(err, logObj); // eslint-disable-line @typescript-eslint/no-explicit-any
+            case 'ERR_PNPM_FETCH_401':
+            case 'ERR_PNPM_FETCH_403':
+                return reportAuthError(err, logObj, config); // eslint-disable-line @typescript-eslint/no-explicit-any
+            default: {
+                // Errors with unknown error codes are printed with stack trace
+                if (!err.code?.startsWith?.('ERR_PNPM_')) {
+                    return formatGenericError(err.message ?? logObj.message, err.stack);
+                }
+                return {
+                    title: err.message ?? '',
+                    body: logObj.hint,
+                };
+            }
+        }
+    }
+    return { title: logObj.message };
+}
+function formatPkgNameVer({ name, version }) {
+    return version == null
+        ? name
+        : `${name}@${version}`;
+}
+function formatPkgsStack(pkgsStack) {
+    return `This error happened while installing the dependencies of \
+${formatPkgNameVer(pkgsStack[0])}\
+${pkgsStack.slice(1).map((pkgInfo) => `${EOL} at ${formatPkgNameVer(pkgInfo)}`).join('')}`;
+}
+function formatNoMatchingVersion(err, msg) {
+    // Errors raised by the install/dlx/self-update layer after the resolver
+    // surfaces violations may not carry the original packageMeta. In that
+    // case the error message alone already names every offending entry,
+    // so we just echo it through without the registry-metadata appendix.
+    const meta = msg.packageMeta;
+    if (!meta) {
+        return { title: err.message };
+    }
+    const latestVersion = meta['dist-tags'].latest;
+    let output = `The latest release of ${meta.name} is "${latestVersion}".`;
+    const latestTime = meta.time?.[latestVersion];
+    if (latestTime) {
+        output += ` Published at ${stringifyDate(latestTime)}`;
+    }
+    output += EOL;
+    if (!equals(Object.keys(meta['dist-tags']), ['latest'])) {
+        output += EOL + 'Other releases are:' + EOL;
+        for (const tag in meta['dist-tags']) {
+            if (tag !== 'latest') {
+                const version = meta['dist-tags'][tag];
+                output += `  * ${tag}: ${version}`;
+                const time = meta.time?.[version];
+                if (time) {
+                    output += ` published at ${stringifyDate(time)}`;
+                }
+                output += EOL;
+            }
+        }
+    }
+    output += `${EOL}If you need the full list of all ${Object.keys(meta.versions).length} published versions run "pnpm view ${meta.name} versions".`;
+    return {
+        title: err.message,
+        body: output,
+    };
+}
+function stringifyDate(dateStr) {
+    const now = Date.now();
+    const oneDayAgo = now - 24 * 60 * 60 * 1000;
+    const date = new Date(dateStr);
+    if (date.getTime() < oneDayAgo) {
+        return date.toLocaleDateString();
+    }
+    return `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+}
+function reportUnexpectedStore(err, msg) {
+    return {
+        title: err.message,
+        body: `The dependencies at "${msg.modulesDir}" are currently linked from the store at "${msg.expectedStorePath}".
+
+pnpm now wants to use the store at "${msg.actualStorePath}" to link dependencies.
+
+If you want to use the new store location, reinstall your dependencies with "pnpm install".
+
+You may change the global store location by running "pnpm config set store-dir <dir> --global".
+(This error may happen if the node_modules was installed with a different major version of pnpm)`,
+    };
+}
+function reportUnexpectedVirtualStoreDir(err, msg) {
+    return {
+        title: err.message,
+        body: `The dependencies at "${msg.modulesDir}" are currently symlinked from the virtual store directory at "${msg.expected}".
+
+pnpm now wants to use the virtual store at "${msg.actual}" to link dependencies from the store.
+
+If you want to use the new virtual store location, reinstall your dependencies with "pnpm install".
+
+You may change the virtual store location by changing the value of the virtual-store-dir config.`,
+    };
+}
+function reportStoreBreakingChange(msg) {
+    let output = `Store path: ${colorPath(msg.storePath)}
+
+Run "pnpm install" to recreate node_modules.`;
+    if (msg.additionalInformation) {
+        output = `${output}${EOL}${EOL}${msg.additionalInformation}`;
+    }
+    output += formatRelatedSources(msg);
+    return {
+        title: 'The store used for the current node_modules is incompatible with the current version of pnpm',
+        body: output,
+    };
+}
+function reportModulesBreakingChange(msg) {
+    let output = `node_modules path: ${colorPath(msg.modulesPath)}
+
+Run ${highlight('pnpm install')} to recreate node_modules.`;
+    if (msg.additionalInformation) {
+        output = `${output}${EOL}${EOL}${msg.additionalInformation}`;
+    }
+    output += formatRelatedSources(msg);
+    return {
+        title: 'The current version of pnpm is not compatible with the available node_modules structure',
+        body: output,
+    };
+}
+function formatRelatedSources(msg) {
+    let output = '';
+    if (!msg.relatedIssue && !msg.relatedPR)
+        return output;
+    output += EOL;
+    if (msg.relatedIssue) {
+        output += EOL + `Related issue: ${colorPath(`https://github.com/pnpm/pnpm/issues/${msg.relatedIssue}`)}`;
+    }
+    if (msg.relatedPR) {
+        output += EOL + `Related PR: ${colorPath(`https://github.com/pnpm/pnpm/pull/${msg.relatedPR}`)}`;
+    }
+    return output;
+}
+function formatGenericError(errorMessage, stack) {
+    if (stack) {
+        let prettyStack;
+        try {
+            prettyStack = new StackTracey(stack).asTable();
+        }
+        catch {
+            prettyStack = stack.toString();
+        }
+        if (prettyStack) {
+            return {
+                title: errorMessage,
+                body: prettyStack,
+            };
+        }
+    }
+    return { title: errorMessage };
+}
+function formatErrorSummary(message, code) {
+    return `${chalk.bgRed.red('[')}${chalk.bgRed.black(code ?? 'ERROR')}${chalk.bgRed.red(']')} ${chalk.red(message)}`;
+}
+function reportModifiedDependency(msg) {
+    return {
+        title: 'Packages in the store have been mutated',
+        body: `These packages are modified:
+${msg.modified.map((pkgPath) => colorPath(pkgPath)).join(EOL)}
+
+You can run ${highlight('pnpm install --force')} to refetch the modified packages`,
+    };
+}
+function reportLockfileBreakingChange(err, _msg) {
+    return {
+        title: err.message,
+        body: `Run with the ${highlight('--force')} parameter to recreate the lockfile.`,
+    };
+}
+function formatRecursiveCommandSummary(msg) {
+    const output = EOL + `Summary: ${chalk.red(`${msg.failures.length} fails`)}, ${msg.passes} passes` + EOL + EOL +
+        msg.failures.map(({ message, prefix }) => {
+            return prefix + ':' + EOL + formatErrorSummary(message);
+        }).join(EOL + EOL);
+    return {
+        title: '',
+        body: output,
+    };
+}
+function reportBadTarballSize(err, _msg) {
+    return {
+        title: err.message,
+        body: `Seems like you have internet connection issues.
+Try running the same command again.
+If that doesn't help, try one of the following:
+
+- Set a bigger value for the \`fetch-retries\` config.
+    To check the current value of \`fetch-retries\`, run \`pnpm get fetch-retries\`.
+    To set a new value, run \`pnpm set fetch-retries <number>\`.
+
+- Set \`network-concurrency\` to 1.
+    This change will slow down installation times, so it is recommended to
+    delete the config once the internet connection is good again: \`pnpm config delete network-concurrency\`
+
+NOTE: You may also override configs via flags.
+For instance, \`pnpm install --fetch-retries 5 --network-concurrency 1\``,
+    };
+}
+function reportLifecycleError(msg) {
+    if (msg.stage === 'test') {
+        return { title: 'Test failed. See above for more details.' };
+    }
+    if (typeof msg.errno === 'number') {
+        return { title: `Command failed with exit code ${msg.errno}.` };
+    }
+    return { title: 'Command failed.' };
+}
+function reportEngineError(msg) {
+    let output = '';
+    if (msg.wanted.pnpm) {
+        output += `\
+Your pnpm version is incompatible with "${msg.packageId}".
+
+Expected version: ${msg.wanted.pnpm}
+Got: ${msg.current.pnpm}
+
+This is happening because the package's manifest has an engines.pnpm field specified.
+To fix this issue, install the required pnpm version globally.
+
+To install the latest version of pnpm, run "pnpm i -g pnpm".
+To check your pnpm version, run "pnpm -v".`;
+    }
+    if (msg.wanted.node) {
+        if (output)
+            output += EOL + EOL;
+        output += `\
+Your Node version is incompatible with "${msg.packageId}".
+
+Expected version: ${msg.wanted.node}
+Got: ${msg.current.node}
+
+This is happening because the package's manifest has an engines.node field specified.
+To fix this issue, install the required Node version.`;
+    }
+    return {
+        title: 'Unsupported environment (bad pnpm and/or Node.js version)',
+        body: output,
+    };
+}
+function reportAuthError(err, msg, config) {
+    const foundSettings = [];
+    for (const [key, value] of Object.entries(config?.authConfig ?? {})) {
+        if (key[0] === '@') {
+            foundSettings.push(`${key}=${String(value)}`);
+            continue;
+        }
+        if (key.endsWith('_auth') ||
+            key.endsWith('_authToken') ||
+            key.endsWith('username') ||
+            key.endsWith('_password')) {
+            foundSettings.push(`${key}=${hideSecureInfo(key, value)}`);
+        }
+    }
+    let output = msg.hint ? `${msg.hint}${EOL}${EOL}` : '';
+    if (foundSettings.length === 0) {
+        output += `No authorization settings were found in the configs.
+Try to log in to the registry by running "pnpm login"
+or add the auth tokens manually to the ~/.npmrc file.`;
+    }
+    else {
+        output += `These authorization settings were found:
+${foundSettings.join('\n')}`;
+    }
+    return {
+        title: err.message,
+        body: output,
+    };
+}
+function hideSecureInfo(key, value) {
+    if (key.endsWith('_password'))
+        return '[hidden]';
+    if (key.endsWith('_auth') || key.endsWith('_authToken'))
+        return `${value.substring(0, 4)}[hidden]`;
+    return value;
+}
+function reportPeerDependencyIssuesError(err, msg) {
+    const hasMissingPeers = getHasMissingPeers(msg.issuesByProjects);
+    const hints = [];
+    if (hasMissingPeers) {
+        hints.push(`To auto-install peer dependencies, add the following to "pnpm-workspace.yaml" in your project root:
+
+  autoInstallPeers: true`);
+    }
+    hints.push(`To disable failing on peer dependency issues, add the following to pnpm-workspace.yaml in your project root:
+
+  strictPeerDependencies: false`);
+    const formattedHints = hints.map((hint) => `hint: ${hint}`).join('\n');
+    const rendered = renderPeerIssues(msg.issuesByProjects);
+    return {
+        title: err.message,
+        body: rendered ? `${rendered}\n${formattedHints}` : formattedHints,
+    };
+}
+function getHasMissingPeers(issuesByProjects) {
+    return Object.values(issuesByProjects)
+        .some((issues) => Object.values(issues.missing).flat().some(({ optional }) => !optional));
+}
+function reportDedupeCheckIssuesError(err, msg) {
+    return {
+        title: err.message,
+        body: `\
+${renderDedupeCheckIssues(msg.dedupeCheckIssues)}
+Run ${chalk.yellow('pnpm dedupe')} to apply the changes above.
+`,
+    };
+}
+function reportSpecNotSupportedByAnyResolverError(err, logObj) {
+    // If the catalog protocol specifier was sent to a "real resolver", it'll
+    // eventually throw a "specifier not supported" error since the catalog
+    // protocol is meant to be replaced before it's passed to any of the real
+    // resolvers.
+    //
+    // If this kind of error is thrown, and the dependency bareSpecifier is using the
+    // catalog protocol it's most likely because we're trying to install an out of
+    // repo dependency that was published incorrectly. For example, it may be been
+    // mistakenly published with 'npm publish' instead of 'pnpm publish'. Report a
+    // more clear error in this case.
+    if (logObj.package?.bareSpecifier?.startsWith('catalog:')) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return reportExternalCatalogProtocolError(err, logObj);
+    }
+    return {
+        title: err.message ?? '',
+        body: logObj.hint,
+    };
+}
+function reportExternalCatalogProtocolError(err, logObj) {
+    const { pkgsStack } = logObj;
+    const problemDep = pkgsStack?.[0];
+    let body = `\
+An external package outside of the pnpm workspace declared a dependency using
+the catalog protocol. This is likely a bug in that external package. Only
+packages within the pnpm workspace may use catalogs. Usages of the catalog
+protocol are replaced with real specifiers on 'pnpm publish'.
+`;
+    if (problemDep != null) {
+        body += `\
+
+This is likely a bug in the publishing automation of this package. Consider filing
+a bug with the authors of:
+
+  ${highlight(formatPkgNameVer(problemDep))}
+`;
+    }
+    return {
+        title: err.message,
+        body,
+    };
+}
+//# sourceMappingURL=reportError.js.map