@pnpm/releasing.commands 1100.7.0 → 1100.7.1

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @pnpm/releasing.commands
 
+## 1100.7.1
+
+### 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).
+
+- Support the `from-git` argument in the `pnpm version` command.
+
+- Updated dependencies:
+  - @pnpm/bins.resolver@1100.0.11
+  - @pnpm/catalogs.types@1100.0.1
+  - @pnpm/cli.common-cli-options-help@1100.0.3
+  - @pnpm/cli.utils@1101.0.19
+  - @pnpm/config.pick-registry-for-package@1100.0.12
+  - @pnpm/config.reader@1101.14.0
+  - @pnpm/constants@1100.0.1
+  - @pnpm/deps.path@1100.0.11
+  - @pnpm/engine.runtime.commands@1100.1.16
+  - @pnpm/engine.runtime.node-resolver@1101.1.18
+  - @pnpm/error@1100.1.0
+  - @pnpm/exec.lifecycle@1100.1.8
+  - @pnpm/exec.pnpm-cli-runner@1100.0.2
+  - @pnpm/fetching.directory-fetcher@1100.0.25
+  - @pnpm/fetching.types@1100.0.3
+  - @pnpm/fs.indexed-pkg-importer@1100.0.21
+  - @pnpm/fs.is-empty-dir-or-nothing@1100.0.1
+  - @pnpm/fs.packlist@1100.0.4
+  - @pnpm/installing.client@1100.2.20
+  - @pnpm/installing.commands@1100.12.0
+  - @pnpm/lockfile.fs@1100.1.14
+  - @pnpm/lockfile.types@1100.0.16
+  - @pnpm/network.auth-header@1101.1.6
+  - @pnpm/network.fetch@1100.1.8
+  - @pnpm/network.git-utils@1100.0.3
+  - @pnpm/network.web-auth@1101.3.0
+  - @pnpm/releasing.exportable-manifest@1100.1.15
+  - @pnpm/releasing.versioning@1100.2.1
+  - @pnpm/resolving.npm-resolver@1102.1.8
+  - @pnpm/resolving.registry.types@1100.1.6
+  - @pnpm/resolving.resolver-base@1100.5.4
+  - @pnpm/types@1101.6.0
+  - @pnpm/workspace.projects-filter@1100.0.32
+  - @pnpm/workspace.projects-sorter@1100.0.11
+  - @pnpm/workspace.workspace-manifest-writer@1100.0.18
+
 ## 1100.7.0
 
 ### Minor Changes

package/lib/change/index.d.ts

@@ -0,0 +1,42 @@
+import type { Config } from '@pnpm/config.reader';
+import { type ChangeIntent, type ReleasePlan, type WorkspaceProject } from '@pnpm/releasing.versioning';
+import type { Project, VersioningSettings } from '@pnpm/types';
+import { type UnpublishedProbeOptions } from '../resolveUnpublishedDirs.js';
+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 ChangeCommandOptions = Pick<Config, 'changedFilesIgnorePattern' | 'dir' | 'testPattern' | 'versioning' | 'workspaceDir'> & UnpublishedProbeOptions & {
+    allProjects?: Project[];
+    bump?: string;
+    summary?: string;
+};
+export declare function handler(opts: ChangeCommandOptions, params: string[]): Promise<string>;
+export declare function renderReleasePlan(plan: ReleasePlan): string;
+export interface ReleasableProject {
+    name: string;
+    /** Workspace-relative project directory. */
+    dir: string;
+    /**
+     * How an intent file or versioning config should reference this project:
+     * the bare name, or the `./`-prefixed directory when the name is shared by
+     * several workspace projects.
+     */
+    ref: string;
+}
+/**
+ * The projects a change intent may demand a release from: named, carrying a
+ * valid semver version, and not frozen by `versioning.ignore`. Matches the
+ * participant set of the release-plan assembler.
+ */
+export declare function getReleasableProjects(allProjects: Array<Pick<Project, 'manifest' | 'rootDir'>>, workspaceDir: string, versioning?: VersioningSettings): ReleasableProject[];
+export declare function toWorkspaceProjects(allProjects: Array<Pick<Project, 'manifest' | 'rootDir'>>): WorkspaceProject[];
+export type { ChangeIntent };
+export declare const change: {
+    handler: typeof handler;
+    help: typeof help;
+    commandNames: string[];
+    cliOptionsTypes: typeof cliOptionsTypes;
+    rcOptionsTypes: typeof rcOptionsTypes;
+    recursiveByDefault: boolean;
+};

package/lib/change/index.js

@@ -0,0 +1,248 @@
+import { checkbox, input, Separator } from '@inquirer/prompts';
+import { PnpmError } from '@pnpm/error';
+import { assembleReleasePlan, BUMP_TYPES, indexProjectRefs, readChangeIntents, readLedger, toProjectDir, writeChangeIntent, } from '@pnpm/releasing.versioning';
+import { getChangedProjects } from '@pnpm/workspace.projects-filter';
+import { safeExeca as execa } from 'execa';
+import { renderHelp } from 'render-help';
+import { valid } from 'semver';
+import { resolveUnpublishedDirs } from '../resolveUnpublishedDirs.js';
+export function rcOptionsTypes() {
+    return {};
+}
+export function cliOptionsTypes() {
+    return {
+        bump: String,
+        summary: String,
+        recursive: Boolean,
+    };
+}
+export const commandNames = ['change'];
+export function help() {
+    return renderHelp({
+        description: 'Records a change intent: which packages a change affects, the bump type for each, and a summary that becomes the changelog entry. The intent file is written to .changeset/ in the changesets format.',
+        usages: [
+            'pnpm change [--bump <type>] [--summary <text>] [<pkg>...]',
+            'pnpm change status',
+        ],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: `Bump type for the named packages: ${BUMP_TYPES.join(', ')}. "none" records an explicit decline — the change needs no release`,
+                        name: '--bump <type>',
+                    },
+                    {
+                        description: 'The summary for the changelog entry. Runs non-interactively when given together with package names',
+                        name: '--summary <text>',
+                    },
+                ],
+            },
+        ],
+    });
+}
+export async function handler(opts, params) {
+    const workspaceDir = opts.workspaceDir;
+    if (!workspaceDir) {
+        throw new PnpmError('WORKSPACE_ONLY', 'pnpm change is only supported in a workspace');
+    }
+    // Only the exact no-option invocation is the status form, so a package
+    // that happens to be named "status" stays recordable.
+    if (params.length === 1 && params[0] === 'status' && opts.bump == null && opts.summary == null) {
+        return renderStatus(workspaceDir, opts);
+    }
+    return recordChange(workspaceDir, opts, params);
+}
+async function recordChange(workspaceDir, opts, params) {
+    const releasable = getReleasableProjects(opts.allProjects ?? [], workspaceDir, opts.versioning);
+    if (releasable.length === 0) {
+        throw new PnpmError('VERSIONING_NO_PACKAGES', 'No releasable packages found in this workspace');
+    }
+    const releasableDirs = new Set(releasable.map((project) => project.dir));
+    const refs = indexProjectRefs(opts.allProjects ?? [], workspaceDir);
+    for (const ref of params) {
+        const dirs = refs.refToDirs(ref);
+        if (dirs.length > 1) {
+            throw new PnpmError('VERSIONING_AMBIGUOUS_PACKAGE', `${ref} matches multiple workspace projects: ${dirs.map((dir) => `./${dir}`).join(', ')}. Reference the project by directory instead.`);
+        }
+        if (dirs.length === 0 || !releasableDirs.has(dirs[0])) {
+            throw new PnpmError('VERSIONING_UNKNOWN_PACKAGE', `${ref} is not a releasable package of this workspace`);
+        }
+    }
+    if (opts.bump != null && !BUMP_TYPES.includes(opts.bump)) {
+        throw new PnpmError('VERSIONING_INVALID_BUMP', `Invalid bump type: ${opts.bump}. Expected one of ${BUMP_TYPES.join(', ')}`);
+    }
+    const pkgRefs = params.length > 0
+        ? params
+        : await promptForPackages(releasable, workspaceDir, opts);
+    const releases = opts.bump != null
+        ? Object.fromEntries(pkgRefs.map((ref) => [ref, opts.bump]))
+        : await promptBumpTypes(pkgRefs);
+    const summary = opts.summary ??
+        await input({ message: 'Summary of the change (becomes the changelog entry):', required: true });
+    const id = await writeChangeIntent(workspaceDir, { releases, summary });
+    return `Recorded change intent .changeset/${id}.md`;
+}
+/**
+ * The affected-packages picker, changesets-style: the packages whose
+ * directories the branch touched are grouped first (under a "changed
+ * packages" heading) and preselected, the rest listed below under "unchanged
+ * packages". A name shared by several projects is offered under its directory
+ * reference so the written intent stays unambiguous. Change detection is
+ * best-effort — outside a git repo, or when no base branch can be found, the
+ * list falls back to a flat, unselected picker.
+ */
+async function promptForPackages(releasable, workspaceDir, opts) {
+    const changedDirs = await detectChangedDirs(releasable, workspaceDir, opts);
+    const label = (project) => project.ref === project.name ? project.name : `${project.name} (./${project.dir})`;
+    let choices;
+    if (changedDirs.size > 0) {
+        const changed = releasable.filter((project) => changedDirs.has(project.dir));
+        const unchanged = releasable.filter((project) => !changedDirs.has(project.dir));
+        choices = [
+            new Separator('changed packages'),
+            ...changed.map((project) => ({ value: project.ref, name: label(project), checked: true })),
+            ...(unchanged.length > 0 ? [new Separator('unchanged packages')] : []),
+            ...unchanged.map((project) => ({ value: project.ref, name: label(project) })),
+        ];
+    }
+    else {
+        choices = releasable.map((project) => ({ value: project.ref, name: label(project) }));
+    }
+    return checkbox({
+        message: 'Which packages does this change affect?',
+        choices,
+        required: true,
+    });
+}
+/**
+ * The workspace-relative directories the current branch changed, relative to
+ * the base branch, using the same detection behind `--filter="[<ref>]"`.
+ * Returns an empty set on any failure so the picker degrades to a flat list.
+ */
+async function detectChangedDirs(releasable, workspaceDir, opts) {
+    const baseCommit = await detectBaseCommit(workspaceDir);
+    if (baseCommit == null)
+        return new Set();
+    try {
+        const projectDirs = (opts.allProjects ?? []).map((project) => project.rootDir);
+        const [changedRootDirs] = await getChangedProjects(projectDirs, baseCommit, {
+            workspaceDir,
+            testPattern: opts.testPattern,
+            changedFilesIgnorePattern: opts.changedFilesIgnorePattern,
+        });
+        const releasableDirs = new Set(releasable.map((project) => project.dir));
+        return new Set(changedRootDirs
+            .map((rootDir) => toProjectDir(workspaceDir, rootDir))
+            .filter((dir) => releasableDirs.has(dir)));
+    }
+    catch {
+        return new Set();
+    }
+}
+/** The merge-base of HEAD with the default branch, or `undefined`. */
+async function detectBaseCommit(cwd) {
+    for (const branch of ['main', 'master']) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const { stdout } = await execa('git', ['merge-base', 'HEAD', branch], { cwd });
+            const commit = String(stdout).trim();
+            if (commit !== '')
+                return commit;
+        }
+        catch {
+            // Try the next candidate branch.
+        }
+    }
+    return undefined;
+}
+/**
+ * The changesets-style bump picker: ask which packages get a major bump, then
+ * which of the rest get a minor, and default whatever remains to patch. One
+ * multiselect per level reads far better than a per-package prompt when many
+ * packages are affected.
+ */
+async function promptBumpTypes(pkgRefs) {
+    const bumpByRef = new Map();
+    let remaining = [...pkgRefs];
+    for (const bumpType of ['major', 'minor']) {
+        if (remaining.length === 0)
+            break;
+        // eslint-disable-next-line no-await-in-loop
+        const chosen = new Set(await checkbox({
+            message: `Which packages should have a ${bumpType} bump?`,
+            choices: remaining.map((ref) => ({ value: ref })),
+        }));
+        for (const ref of chosen)
+            bumpByRef.set(ref, bumpType);
+        remaining = remaining.filter((ref) => !chosen.has(ref));
+    }
+    for (const ref of remaining)
+        bumpByRef.set(ref, 'patch');
+    // Emit in the original selection order rather than grouped by bump level.
+    return Object.fromEntries(pkgRefs.map((ref) => [ref, bumpByRef.get(ref)]));
+}
+async function renderStatus(workspaceDir, opts) {
+    const intents = await readChangeIntents(workspaceDir);
+    const ledger = await readLedger(workspaceDir);
+    const baseArgs = {
+        workspaceDir,
+        projects: toWorkspaceProjects(opts.allProjects ?? []),
+        intents,
+        ledger,
+        versioning: opts.versioning,
+    };
+    const unpublishedDirs = await resolveUnpublishedDirs(assembleReleasePlan(baseArgs), opts);
+    const plan = assembleReleasePlan({ ...baseArgs, unpublishedDirs });
+    if (plan.releases.length === 0) {
+        return 'No pending changes.';
+    }
+    const consumedIds = new Set(plan.releases.flatMap((release) => release.intents.map((intent) => intent.id)));
+    let output = 'Pending change intents:\n';
+    for (const intent of intents.filter(({ id }) => consumedIds.has(id))) {
+        output += `  .changeset/${intent.id}.md\n`;
+    }
+    output += '\n';
+    output += renderReleasePlan(plan);
+    return output;
+}
+export function renderReleasePlan(plan) {
+    let output = 'Release plan:\n';
+    for (const release of plan.releases) {
+        output += `  ${release.name}: ${release.currentVersion} → ${release.newVersion} (${release.bumpType}, via ${release.causes.join('+')})\n`;
+    }
+    return output;
+}
+/**
+ * The projects a change intent may demand a release from: named, carrying a
+ * valid semver version, and not frozen by `versioning.ignore`. Matches the
+ * participant set of the release-plan assembler.
+ */
+export function getReleasableProjects(allProjects, workspaceDir, versioning) {
+    const refs = indexProjectRefs(allProjects, workspaceDir);
+    const ignoredDirs = new Set((versioning?.ignore ?? []).flatMap((ref) => refs.refToDirs(ref)));
+    return allProjects
+        .filter(({ manifest }) => manifest.name != null &&
+        manifest.version != null &&
+        valid(manifest.version) != null)
+        .map((project) => ({ name: project.manifest.name, dir: toProjectDir(workspaceDir, project.rootDir) }))
+        .filter(({ dir }) => !ignoredDirs.has(dir))
+        .map(({ name, dir }) => ({
+        name,
+        dir,
+        ref: refs.nameToDirs(name).length > 1 ? `./${dir}` : name,
+    }))
+        .sort((left, right) => left.ref.localeCompare(right.ref));
+}
+export function toWorkspaceProjects(allProjects) {
+    return allProjects.map((project) => ({ rootDir: project.rootDir, manifest: project.manifest }));
+}
+export const change = {
+    handler,
+    help,
+    commandNames,
+    cliOptionsTypes,
+    rcOptionsTypes,
+    recursiveByDefault: true,
+};
+//# sourceMappingURL=index.js.map

package/lib/deploy/createDeployFiles.d.ts

@@ -0,0 +1,26 @@
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { DependenciesField, PnpmSettings, Project, ProjectId, ProjectManifest } from '@pnpm/types';
+export interface CreateDeployFilesOptions {
+    allProjects: Array<Pick<Project, 'manifest' | 'rootDirRealPath'>>;
+    deployDir: string;
+    include: {
+        [dependenciesField in DependenciesField]: boolean;
+    };
+    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, include, lockfile, lockfileDir, patchedDependencies, selectedProjectManifest, projectId, rootProjectManifestDir, allowBuilds, }: CreateDeployFilesOptions): DeployFiles;

package/lib/deploy/createDeployFiles.js

@@ -0,0 +1,255 @@
+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, include, 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;
+            }
+            resolveResult.packageName ??= name;
+            targetSpecifiers[name] = targetDependencies[name] =
+                resolveResult.resolvedPath === deployedProjectRealPath ? 'link:.' : createFileUrlDepPath(resolveResult, allProjects);
+        }
+    }
+    const deployPackageSnapshots = filterDeployPackageSnapshots(targetSnapshot, targetPackageSnapshots, include);
+    const result = {
+        lockfile: {
+            ...lockfile,
+            // The deployed manifest contains concrete versions, and catalogs are not copied to the target.
+            catalogs: undefined,
+            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: deployPackageSnapshots,
+        },
+        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 filterDeployPackageSnapshots(importer, packages, include) {
+    const queue = [];
+    const enqueue = (dependencies) => {
+        for (const [alias, reference] of Object.entries(dependencies ?? {})) {
+            const depPath = dp.refToRelative(reference, alias);
+            if (depPath != null && packages[depPath] != null)
+                queue.push(depPath);
+        }
+    };
+    if (include.dependencies)
+        enqueue(importer.dependencies);
+    if (include.devDependencies)
+        enqueue(importer.devDependencies);
+    if (include.optionalDependencies)
+        enqueue(importer.optionalDependencies);
+    const reachable = new Set();
+    let head = 0;
+    while (head < queue.length) {
+        const depPath = queue[head++];
+        if (reachable.has(depPath))
+            continue;
+        reachable.add(depPath);
+        const snapshot = packages[depPath];
+        if (snapshot == null)
+            continue;
+        enqueue(snapshot.dependencies);
+        if (include.optionalDependencies)
+            enqueue(snapshot.optionalDependencies);
+    }
+    return Object.fromEntries(Array.from(reachable, (depPath) => [depPath, packages[depPath]]));
+}
+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;
+        }
+        resolveResult.packageName ??= key;
+        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 { name, 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 ?? ''}`;
+    parseResult.packageName = name;
+    return parseResult;
+}
+function createFileUrlDepPath({ resolvedPath, suffix, packageName }, allProjects) {
+    const depFileUrl = url.pathToFileURL(resolvedPath).toString();
+    const project = allProjects.find(project => project.rootDirRealPath === resolvedPath);
+    const name = project?.manifest.name ?? packageName ?? path.basename(resolvedPath);
+    return `${name}@${depFileUrl}${suffix ?? ''}`;
+}
+//# sourceMappingURL=createDeployFiles.js.map

package/lib/deploy/deploy.d.ts

@@ -0,0 +1,12 @@
+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 const overridableByScript = true;
+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>;