@pnpm/releasing.commands 1000.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/deploy/createDeployFiles.d.ts

@@ -0,0 +1,23 @@
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { PnpmSettings, Project, ProjectId, ProjectManifest } from '@pnpm/types';
+export interface CreateDeployFilesOptions {
+    allProjects: Array<Pick<Project, 'manifest' | 'rootDirRealPath'>>;
+    deployDir: string;
+    lockfile: LockfileObject;
+    lockfileDir: string;
+    patchedDependencies?: PnpmSettings['patchedDependencies'];
+    selectedProjectManifest: ProjectManifest;
+    projectId: ProjectId;
+    rootProjectManifestDir: string;
+    allowBuilds?: Record<string, boolean | string>;
+}
+export interface DeployWorkspaceManifest {
+    allowBuilds?: Record<string, boolean | string>;
+    patchedDependencies?: Record<string, string>;
+}
+export interface DeployFiles {
+    lockfile: LockfileObject;
+    manifest: ProjectManifest;
+    workspaceManifest?: DeployWorkspaceManifest;
+}
+export declare function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDir, patchedDependencies, selectedProjectManifest, projectId, rootProjectManifestDir, allowBuilds }: CreateDeployFilesOptions): DeployFiles;

package/lib/deploy/createDeployFiles.js

@@ -0,0 +1,218 @@
+import path from 'node:path';
+import url from 'node:url';
+import * as dp from '@pnpm/deps.path';
+import normalizePath from 'normalize-path';
+const DEPENDENCIES_FIELD = ['dependencies', 'devDependencies', 'optionalDependencies'];
+export function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDir, patchedDependencies, selectedProjectManifest, projectId, rootProjectManifestDir, allowBuilds, }) {
+    const deployedProjectRealPath = path.resolve(lockfileDir, projectId);
+    const inputSnapshot = lockfile.importers[projectId];
+    const targetSnapshot = {
+        ...inputSnapshot,
+        specifiers: {},
+        dependencies: {},
+        devDependencies: {},
+        optionalDependencies: {},
+    };
+    const targetPackageSnapshots = {};
+    for (const name in lockfile.packages) {
+        const inputDepPath = name;
+        const inputSnapshot = lockfile.packages[inputDepPath];
+        const resolveResult = resolveLinkOrFile(inputDepPath, {
+            lockfileDir,
+            projectRootDirRealPath: rootProjectManifestDir,
+        });
+        const outputDepPath = resolveResult
+            ? createFileUrlDepPath(resolveResult, allProjects)
+            : inputDepPath;
+        targetPackageSnapshots[outputDepPath] = convertPackageSnapshot(inputSnapshot, {
+            allProjects,
+            deployDir,
+            deployedProjectRealPath,
+            lockfileDir,
+            projectRootDirRealPath: rootProjectManifestDir,
+        });
+    }
+    for (const importerPath in lockfile.importers) {
+        if (importerPath === projectId)
+            continue;
+        const projectSnapshot = lockfile.importers[importerPath];
+        const projectRootDirRealPath = path.resolve(lockfileDir, importerPath);
+        const packageSnapshot = convertProjectSnapshotToPackageSnapshot(projectSnapshot, {
+            allProjects,
+            deployDir,
+            lockfileDir,
+            deployedProjectRealPath,
+            projectRootDirRealPath,
+        });
+        const depPath = createFileUrlDepPath({ resolvedPath: projectRootDirRealPath }, allProjects);
+        targetPackageSnapshots[depPath] = packageSnapshot;
+    }
+    for (const field of DEPENDENCIES_FIELD) {
+        const targetDependencies = targetSnapshot[field] ?? {};
+        const targetSpecifiers = targetSnapshot.specifiers;
+        const inputDependencies = inputSnapshot[field] ?? {};
+        for (const name in inputDependencies) {
+            const version = inputDependencies[name];
+            const resolveResult = resolveLinkOrFile(version, {
+                lockfileDir,
+                projectRootDirRealPath: path.resolve(lockfileDir, projectId),
+            });
+            if (!resolveResult) {
+                targetSpecifiers[name] = targetDependencies[name] = version;
+                continue;
+            }
+            targetSpecifiers[name] = targetDependencies[name] =
+                resolveResult.resolvedPath === deployedProjectRealPath ? 'link:.' : createFileUrlDepPath(resolveResult, allProjects);
+        }
+    }
+    const result = {
+        lockfile: {
+            ...lockfile,
+            patchedDependencies: undefined,
+            overrides: undefined, // the effects of the overrides should already be part of the package snapshots
+            packageExtensionsChecksum: undefined, // the effects of the package extensions should already be part of the package snapshots
+            pnpmfileChecksum: undefined, // the effects of the pnpmfile should already be part of the package snapshots
+            settings: {
+                ...lockfile.settings,
+                injectWorkspacePackages: undefined, // the effects of injecting workspace packages should already be part of the lockfile
+            },
+            importers: {
+                ['.']: targetSnapshot,
+            },
+            packages: targetPackageSnapshots,
+        },
+        manifest: {
+            ...selectedProjectManifest,
+            dependencies: targetSnapshot.dependencies,
+            devDependencies: targetSnapshot.devDependencies,
+            optionalDependencies: targetSnapshot.optionalDependencies,
+        },
+    };
+    if (lockfile.patchedDependencies && patchedDependencies) {
+        result.lockfile.patchedDependencies = { ...lockfile.patchedDependencies };
+        const deployManifestPatchedDeps = {};
+        for (const name in patchedDependencies) {
+            const absolutePath = patchedDependencies[name];
+            const relativePath = normalizePath(path.relative(deployDir, absolutePath));
+            deployManifestPatchedDeps[name] = relativePath;
+        }
+        result.workspaceManifest = {
+            ...result.workspaceManifest,
+            patchedDependencies: deployManifestPatchedDeps,
+        };
+    }
+    if (allowBuilds) {
+        result.workspaceManifest = {
+            ...result.workspaceManifest,
+            allowBuilds,
+        };
+    }
+    return result;
+}
+function convertPackageSnapshot(inputSnapshot, opts) {
+    const inputResolution = inputSnapshot.resolution;
+    let outputResolution;
+    if ('integrity' in inputResolution) {
+        outputResolution = inputResolution;
+    }
+    else if ('tarball' in inputResolution && typeof inputResolution.tarball === 'string') {
+        outputResolution = { ...inputResolution };
+        if (inputResolution.tarball.startsWith('file:')) {
+            const inputPath = inputResolution.tarball.slice('file:'.length);
+            const resolvedPath = path.resolve(opts.lockfileDir, inputPath);
+            const outputPath = normalizePath(path.relative(opts.deployDir, resolvedPath));
+            outputResolution.tarball = `file:${outputPath}`;
+            if ('path' in inputResolution && typeof inputResolution.path === 'string') {
+                outputResolution.path = outputPath;
+            }
+        }
+    }
+    else if (inputResolution.type === 'directory') {
+        const dirResolution = inputResolution;
+        const resolvedPath = path.resolve(opts.lockfileDir, dirResolution.directory);
+        const directory = normalizePath(path.relative(opts.deployDir, resolvedPath));
+        outputResolution = { ...dirResolution, directory };
+    }
+    else if (inputResolution.type === 'git' || inputResolution.type === 'variations') {
+        outputResolution = inputResolution;
+    }
+    else if (inputResolution.type && typeof inputResolution.type === 'string') {
+        // Custom resolution type - pass through as-is
+        outputResolution = inputResolution;
+    }
+    else {
+        throw new Error(`Unknown resolution type: ${JSON.stringify(inputResolution)}`);
+    }
+    return {
+        ...inputSnapshot,
+        resolution: outputResolution,
+        dependencies: convertResolvedDependencies(inputSnapshot.dependencies, opts),
+        optionalDependencies: convertResolvedDependencies(inputSnapshot.optionalDependencies, opts),
+    };
+}
+function convertProjectSnapshotToPackageSnapshot(projectSnapshot, opts) {
+    const resolution = {
+        type: 'directory',
+        directory: normalizePath(path.relative(opts.deployDir, opts.projectRootDirRealPath)),
+    };
+    const dependencies = convertResolvedDependencies(projectSnapshot.dependencies, opts);
+    const optionalDependencies = convertResolvedDependencies(projectSnapshot.optionalDependencies, opts);
+    return {
+        dependencies,
+        optionalDependencies,
+        resolution,
+    };
+}
+function convertResolvedDependencies(input, opts) {
+    if (!input)
+        return undefined;
+    const output = {};
+    for (const key in input) {
+        const version = input[key];
+        const resolveResult = resolveLinkOrFile(version, opts);
+        if (!resolveResult) {
+            output[key] = version;
+            continue;
+        }
+        if (resolveResult.resolvedPath === opts.deployedProjectRealPath) {
+            output[key] = 'link:.'; // the path is relative to the lockfile dir, which means '.' would reference the deploy dir
+            continue;
+        }
+        output[key] = createFileUrlDepPath(resolveResult, opts.allProjects);
+    }
+    return output;
+}
+function resolveLinkOrFile(pkgVer, opts) {
+    const { lockfileDir, projectRootDirRealPath } = opts;
+    function resolveScheme(scheme, base) {
+        if (!pkgVer.startsWith(scheme))
+            return undefined;
+        const { id, peerDepGraphHash: suffix } = dp.parseDepPath(pkgVer.slice(scheme.length));
+        const resolvedPath = path.resolve(base, id);
+        return { scheme, resolvedPath, suffix };
+    }
+    const resolveSchemeResult = resolveScheme('file:', lockfileDir) ?? resolveScheme('link:', projectRootDirRealPath);
+    if (resolveSchemeResult)
+        return resolveSchemeResult;
+    const { nonSemverVersion, patchHash, peerDepGraphHash, version } = dp.parse(pkgVer);
+    if (!nonSemverVersion)
+        return undefined;
+    if (version) {
+        throw new Error(`Something goes wrong, version should be undefined but isn't: ${version}`);
+    }
+    const parseResult = resolveLinkOrFile(nonSemverVersion, opts);
+    if (!parseResult)
+        return undefined;
+    if (parseResult.suffix) {
+        throw new Error(`Something goes wrong, suffix should be undefined but isn't: ${parseResult.suffix}`);
+    }
+    parseResult.suffix = `${patchHash ?? ''}${peerDepGraphHash ?? ''}`;
+    return parseResult;
+}
+function createFileUrlDepPath({ resolvedPath, suffix }, allProjects) {
+    const depFileUrl = url.pathToFileURL(resolvedPath).toString();
+    const project = allProjects.find(project => project.rootDirRealPath === resolvedPath);
+    const name = project?.manifest.name ?? path.basename(resolvedPath);
+    return `${name}@${depFileUrl}${suffix ?? ''}`;
+}
+//# sourceMappingURL=createDeployFiles.js.map

package/lib/deploy/deploy.d.ts

@@ -0,0 +1,11 @@
+import { type Config } from '@pnpm/config.reader';
+import { install } from '@pnpm/installing.commands';
+export declare const shorthands: {
+    legacy: string[];
+};
+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 DeployOptions = Omit<install.InstallCommandOptions, 'useLockfile'> & Pick<Config, 'allowBuilds' | 'forceLegacyDeploy'>;
+export declare function handler(opts: DeployOptions, params: string[]): Promise<void>;

package/lib/deploy/deploy.js

@@ -0,0 +1,270 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { FILTERING } from '@pnpm/cli.common-cli-options-help';
+import { docsUrl } from '@pnpm/cli.utils';
+import { types as configTypes } from '@pnpm/config.reader';
+import { WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
+import { PnpmError } from '@pnpm/error';
+import { fetchFromDir } from '@pnpm/fetching.directory-fetcher';
+import { createIndexedPkgImporter } from '@pnpm/fs.indexed-pkg-importer';
+import { isEmptyDirOrNothing } from '@pnpm/fs.is-empty-dir-or-nothing';
+import { install } from '@pnpm/installing.commands';
+import { getLockfileImporterId, readWantedLockfile, writeWantedLockfile } from '@pnpm/lockfile.fs';
+import { globalWarn, logger } from '@pnpm/logger';
+import { rimraf } from '@zkochan/rimraf';
+import { pick } from 'ramda';
+import { renderHelp } from 'render-help';
+import { writeYamlFile } from 'write-yaml-file';
+import { createDeployFiles } from './createDeployFiles.js';
+import { deployHook } from './deployHook.js';
+const FORCE_LEGACY_DEPLOY = 'force-legacy-deploy';
+export const shorthands = {
+    ...install.shorthands,
+    legacy: [`--config.${FORCE_LEGACY_DEPLOY}=true`],
+};
+const DEPLOY_OWN_OPTIONS = pick([FORCE_LEGACY_DEPLOY], configTypes);
+export function rcOptionsTypes() {
+    return {
+        ...install.rcOptionsTypes(),
+        ...DEPLOY_OWN_OPTIONS,
+    };
+}
+export function cliOptionsTypes() {
+    return {
+        ...install.cliOptionsTypes(),
+        ...DEPLOY_OWN_OPTIONS,
+    };
+}
+export const commandNames = ['deploy'];
+export function help() {
+    return renderHelp({
+        description: 'Experimental! Deploy a package from a workspace',
+        url: docsUrl('deploy'),
+        usages: ['pnpm --filter=<deployed project name> deploy <target directory>'],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: "Packages in `devDependencies` won't be installed",
+                        name: '--prod',
+                        shortAlias: '-P',
+                    },
+                    {
+                        description: 'Only `devDependencies` are installed',
+                        name: '--dev',
+                        shortAlias: '-D',
+                    },
+                    {
+                        description: '`optionalDependencies` are not installed',
+                        name: '--no-optional',
+                    },
+                    {
+                        description: 'Force legacy deploy implementation',
+                        name: '--legacy',
+                    },
+                ],
+            },
+            FILTERING,
+        ],
+    });
+}
+export async function handler(opts, params) {
+    if (!opts.workspaceDir) {
+        let hint;
+        if (opts.rootProjectManifest?.scripts?.['deploy'] != null) {
+            hint = 'Maybe you wanted to invoke "pnpm run deploy"';
+        }
+        throw new PnpmError('CANNOT_DEPLOY', 'A deploy is only possible from inside a workspace', { hint });
+    }
+    const selectedProjects = Object.values(opts.selectedProjectsGraph ?? {});
+    if (selectedProjects.length === 0) {
+        throw new PnpmError('NOTHING_TO_DEPLOY', 'No project was selected for deployment');
+    }
+    if (selectedProjects.length > 1) {
+        throw new PnpmError('CANNOT_DEPLOY_MANY', 'Cannot deploy more than 1 project');
+    }
+    if (params.length !== 1) {
+        throw new PnpmError('INVALID_DEPLOY_TARGET', 'This command requires one parameter');
+    }
+    const selectedProject = selectedProjects[0].package;
+    const deployDirParam = params[0];
+    const deployDir = path.isAbsolute(deployDirParam) ? deployDirParam : path.join(opts.dir, deployDirParam);
+    if (!isEmptyDirOrNothing(deployDir)) {
+        if (!opts.force) {
+            throw new PnpmError('DEPLOY_DIR_NOT_EMPTY', `Deploy path ${deployDir} is not empty`);
+        }
+        logger.warn({ message: 'using --force, deleting deploy path', prefix: deployDir });
+    }
+    await rimraf(deployDir);
+    await fs.promises.mkdir(deployDir, { recursive: true });
+    const includeOnlyPackageFiles = !opts.deployAllFiles;
+    await copyProject(selectedProject.rootDir, deployDir, { includeOnlyPackageFiles });
+    if (opts.sharedWorkspaceLockfile) {
+        const warning = opts.forceLegacyDeploy
+            ? 'Shared workspace lockfile detected but configuration forces legacy deploy implementation.'
+            : await deployFromSharedLockfile(opts, selectedProject, deployDir);
+        if (warning) {
+            globalWarn(warning);
+        }
+        else {
+            return;
+        }
+    }
+    const deployedProject = opts.allProjects?.find(({ rootDir }) => rootDir === selectedProject.rootDir);
+    if (deployedProject) {
+        deployedProject.modulesDir = path.relative(selectedProject.rootDir, path.join(deployDir, 'node_modules'));
+    }
+    await install.handler({
+        ...opts,
+        confirmModulesPurge: false,
+        // Deploy doesn't work with dedupePeerDependents=true currently as for deploy
+        // we need to select a single project for install, while dedupePeerDependents
+        // doesn't work with filters right now.
+        // Related issue: https://github.com/pnpm/pnpm/issues/6858
+        dedupePeerDependents: false,
+        // If enabled, dedupe-injected-deps will symlink workspace packages in the
+        // deployed dir to their original (non-deployed) directory in an attempt to
+        // dedupe workspace packages that don't need to be injected. The deployed
+        // dir shouldn't have symlinks to the original workspace. Disable
+        // dedupe-injected-deps to always inject workspace packages since copying is
+        // desirable.
+        dedupeInjectedDeps: false,
+        // Compute the wanted lockfile correctly by setting pruneLockfileImporters.
+        // Since pnpm deploy only installs dependencies for a single selected
+        // project, other projects in the "importers" lockfile section will be
+        // empty when node-linker=hoisted.
+        //
+        // For example, when deploying project-1, project-2 may not be populated,
+        // even if it has dependencies.
+        //
+        //   importers:
+        //     project-1:
+        //       dependencies:
+        //         foo:
+        //           specifier: ^1.0.0
+        //           version: ^1.0.0
+        //     project-2: {}
+        //
+        // Avoid including these empty importers in the in-memory wanted lockfile.
+        // This is important when node-linker=hoisted to prevent project-2 from
+        // being included in the hoisted install. If project-2 is errantly hoisted
+        // to the root node_modules dir, downstream logic will fail to inject it to
+        // the deploy directory. It's also just weird to include empty importers
+        // that don't matter to the filtered lockfile generated for pnpm deploy.
+        pruneLockfileImporters: true,
+        // The node_modules for a pnpm deploy should be self-contained. The global
+        // virtual store would create symlinks outside of the deploy directory.
+        enableGlobalVirtualStore: false,
+        depth: Infinity,
+        hooks: {
+            ...opts.hooks,
+            readPackage: [
+                ...(opts.hooks?.readPackage ?? []),
+                deployHook,
+            ],
+        },
+        frozenLockfile: false,
+        preferFrozenLockfile: false,
+        // Deploy doesn't work currently with hoisted node_modules.
+        // TODO: make it work as we need to prefer packages from the lockfile during deployment.
+        useLockfile: opts.nodeLinker !== 'hoisted',
+        saveLockfile: false,
+        virtualStoreDir: path.join(deployDir, 'node_modules/.pnpm'),
+        modulesDir: path.relative(opts.workspaceDir, path.join(deployDir, 'node_modules')),
+        rawLocalConfig: {
+            ...opts.rawLocalConfig,
+            // This is a workaround to prevent frozen install in CI envs.
+            'frozen-lockfile': false,
+        },
+        includeOnlyPackageFiles,
+    });
+}
+async function copyProject(src, dest, opts) {
+    const { filesMap } = await fetchFromDir(src, opts);
+    const importPkg = createIndexedPkgImporter('clone-or-copy');
+    importPkg(dest, { filesMap, force: true, resolvedFrom: 'local-dir' });
+}
+async function deployFromSharedLockfile(opts, selectedProject, deployDir) {
+    if (!opts.injectWorkspacePackages) {
+        throw new PnpmError('DEPLOY_NONINJECTED_WORKSPACE', 'By default, starting from pnpm v10, we only deploy from workspaces that have "inject-workspace-packages=true" set', {
+            hint: 'If you want to deploy without using injected dependencies, run "pnpm deploy" with the "--legacy" flag or set "force-legacy-deploy" to true',
+        });
+    }
+    const { allProjects, lockfileDir, rootProjectManifestDir, workspaceDir, } = opts;
+    // The following errors should not be possible. It is a programmer error if they are reached.
+    if (!allProjects)
+        throw new Error('opts.allProjects is undefined.');
+    if (!lockfileDir)
+        throw new Error('opts.lockfileDir is undefined.');
+    if (!workspaceDir)
+        throw new Error('opts.workspaceDir is undefined.');
+    const lockfile = await readWantedLockfile(lockfileDir, { ignoreIncompatible: false });
+    if (!lockfile) {
+        return 'Shared lockfile not found. Falling back to installing without a lockfile.';
+    }
+    const projectId = getLockfileImporterId(lockfileDir, selectedProject.rootDir);
+    const deployFiles = createDeployFiles({
+        allProjects,
+        deployDir,
+        lockfile,
+        lockfileDir,
+        patchedDependencies: opts.patchedDependencies,
+        selectedProjectManifest: selectedProject.manifest,
+        projectId,
+        rootProjectManifestDir,
+        allowBuilds: opts.allowBuilds,
+    });
+    const filesToWrite = [
+        fs.promises.writeFile(path.join(deployDir, 'package.json'), JSON.stringify(deployFiles.manifest, undefined, 2) + '\n'),
+        writeWantedLockfile(deployDir, deployFiles.lockfile),
+    ];
+    if (deployFiles.workspaceManifest) {
+        filesToWrite.push(writeYamlFile(path.join(deployDir, WORKSPACE_MANIFEST_FILENAME), deployFiles.workspaceManifest));
+    }
+    await Promise.all(filesToWrite);
+    try {
+        await install.handler({
+            ...opts,
+            allProjects: undefined,
+            allProjectsGraph: undefined,
+            selectedProjectsGraph: undefined,
+            rootProjectManifest: deployFiles.manifest,
+            // The node_modules for a pnpm deploy should be self-contained. The global
+            // virtual store would create symlinks outside of the deploy directory.
+            enableGlobalVirtualStore: false,
+            rootProjectManifestDir: deployDir,
+            dir: deployDir,
+            lockfileDir: deployDir,
+            workspaceDir: undefined,
+            virtualStoreDir: undefined,
+            modulesDir: undefined,
+            confirmModulesPurge: false,
+            frozenLockfile: true,
+            injectWorkspacePackages: undefined, // the effects of injecting workspace packages should already be part of the package snapshots
+            overrides: undefined, // the effects of the overrides should already be part of the package snapshots
+            packageExtensions: undefined, // the effects of the package extensions should already be part of the package snapshots
+            hooks: {
+                ...opts.hooks,
+                readPackage: [
+                    ...(opts.hooks?.readPackage ?? []),
+                    deployHook,
+                ],
+                calculatePnpmfileChecksum: undefined, // the effects of the pnpmfile should already be part of the package snapshots
+            },
+            rawLocalConfig: {
+                ...opts.rawLocalConfig,
+                'frozen-lockfile': true,
+            },
+        });
+    }
+    catch (error) {
+        globalWarn(`Deployment with a shared lockfile has failed. If this is a bug, please report it at <https://github.com/pnpm/pnpm/issues>.
+As a workaround, add the following to pnpm-workspace.yaml:
+
+  forceLegacyDeploy: true`);
+        throw error;
+    }
+    return undefined;
+}
+//# sourceMappingURL=deploy.js.map

package/lib/deploy/deployHook.d.ts

@@ -0,0 +1,2 @@
+import { type BaseManifest } from '@pnpm/types';
+export declare function deployHook<Pkg extends BaseManifest>(pkg: Pkg): Pkg;

package/lib/deploy/deployHook.js

@@ -0,0 +1,15 @@
+import { DEPENDENCIES_FIELDS } from '@pnpm/types';
+export function deployHook(pkg) {
+    pkg.dependenciesMeta = pkg.dependenciesMeta ?? {};
+    for (const depField of DEPENDENCIES_FIELDS) {
+        for (const [depName, depVersion] of Object.entries(pkg[depField] ?? {})) {
+            if (depVersion.startsWith('workspace:')) {
+                pkg.dependenciesMeta[depName] = {
+                    injected: true,
+                };
+            }
+        }
+    }
+    return pkg;
+}
+//# sourceMappingURL=deployHook.js.map

package/lib/deploy/index.d.ts

@@ -0,0 +1,2 @@
+import * as deploy from './deploy.js';
+export { deploy };

package/lib/deploy/index.js

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

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { deploy } from './deploy/index.js';
+export { pack, publish } from './publish/index.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+export { deploy } from './deploy/index.js';
+export { pack, publish } from './publish/index.js';
+//# sourceMappingURL=index.js.map

package/lib/publish/FailedToPublishError.d.ts

@@ -0,0 +1,22 @@
+import { PnpmError } from '@pnpm/error';
+import type { PackResult } from './pack.js';
+interface PublishErrorProperties<Pack> {
+    readonly pack: Pack;
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: string;
+}
+export declare class FailedToPublishError<Pack extends Pick<PackResult, 'publishedManifest'>> extends PnpmError implements PublishErrorProperties<Pack> {
+    readonly pack: Pack;
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: string;
+    constructor(opts: PublishErrorProperties<Pack>);
+}
+export declare function createFailedToPublishError<Pack extends Pick<PackResult, 'publishedManifest'>>(pack: Pack, fetchResponse: FetchResponse): Promise<FailedToPublishError<Pack>>;
+interface FetchResponse {
+    readonly status: number;
+    readonly statusText: string;
+    readonly text: (this: FetchResponse) => string | Promise<string>;
+}
+export {};

package/lib/publish/FailedToPublishError.js

@@ -0,0 +1,40 @@
+import { PnpmError } from '@pnpm/error';
+export class FailedToPublishError extends PnpmError {
+    pack;
+    status;
+    statusText;
+    text;
+    constructor(opts) {
+        const { pack, status, statusText, text } = opts;
+        const { name, version } = pack.publishedManifest;
+        const statusDisplay = statusText ? `${status} ${statusText}` : status;
+        const trimmedText = text.trim();
+        let message = `Failed to publish package ${name}@${version} (status ${statusDisplay})`;
+        if (trimmedText.includes('\n')) {
+            message += '\nDetails:\n';
+            for (const line of text.trimEnd().split('\n')) {
+                message += `    ${line}\n`;
+            }
+        }
+        else if (trimmedText) {
+            message += `: ${trimmedText}`;
+        }
+        super('FAILED_TO_PUBLISH', message);
+        this.pack = pack;
+        this.status = status;
+        this.statusText = statusText;
+        this.text = text;
+    }
+}
+export async function createFailedToPublishError(pack, fetchResponse) {
+    const { status, statusText } = fetchResponse;
+    let text;
+    try {
+        text = await fetchResponse.text();
+    }
+    catch {
+        text = '';
+    }
+    return new FailedToPublishError({ pack, status, statusText, text });
+}
+//# sourceMappingURL=FailedToPublishError.js.map

package/lib/publish/displayError.d.ts

@@ -0,0 +1 @@
+export declare function displayError(error: unknown): string;