@pnpm/releasing.commands 1100.5.4 → 1100.6.0

package/lib/change/index.d.ts

@@ -0,0 +1,41 @@
+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';
+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'> & {
+    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,245 @@
+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';
+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 plan = assembleReleasePlan({
+        workspaceDir,
+        projects: toWorkspaceProjects(opts.allProjects ?? []),
+        intents,
+        ledger,
+        versioning: opts.versioning,
+    });
+    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

@@ -1,8 +1,11 @@
 import type { LockfileObject } from '@pnpm/lockfile.types';
-import type { PnpmSettings, Project, ProjectId, ProjectManifest } from '@pnpm/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'];
@@ -20,4 +23,4 @@ export interface DeployFiles {
     manifest: ProjectManifest;
     workspaceManifest?: DeployWorkspaceManifest;
 }
-export declare function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDir, patchedDependencies, selectedProjectManifest, projectId, rootProjectManifestDir, allowBuilds, }: CreateDeployFilesOptions): DeployFiles;
+export declare function createDeployFiles({ allProjects, deployDir, include, lockfile, lockfileDir, patchedDependencies, selectedProjectManifest, projectId, rootProjectManifestDir, allowBuilds, }: CreateDeployFilesOptions): DeployFiles;

package/lib/deploy/createDeployFiles.js

@@ -3,7 +3,7 @@ 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, }) {
+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 = {
@@ -61,13 +61,17 @@ export function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDi
                 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
@@ -79,7 +83,7 @@ export function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDi
             importers: {
                 ['.']: targetSnapshot,
             },
-            packages: targetPackageSnapshots,
+            packages: deployPackageSnapshots,
         },
         manifest: {
             ...selectedProjectManifest,
@@ -109,6 +113,37 @@ export function createDeployFiles({ allProjects, deployDir, lockfile, lockfileDi
     }
     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;
@@ -178,6 +213,7 @@ function convertResolvedDependencies(input, opts) {
             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;
@@ -194,7 +230,7 @@ function resolveLinkOrFile(pkgVer, opts) {
     const resolveSchemeResult = resolveScheme('file:', lockfileDir) ?? resolveScheme('link:', projectRootDirRealPath);
     if (resolveSchemeResult)
         return resolveSchemeResult;
-    const { nonSemverVersion, patchHash, peerDepGraphHash, version } = dp.parse(pkgVer);
+    const { name, nonSemverVersion, patchHash, peerDepGraphHash, version } = dp.parse(pkgVer);
     if (!nonSemverVersion)
         return undefined;
     if (version) {
@@ -207,12 +243,13 @@ function resolveLinkOrFile(pkgVer, opts) {
         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 }, allProjects) {
+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 ?? path.basename(resolvedPath);
+    const name = project?.manifest.name ?? packageName ?? path.basename(resolvedPath);
     return `${name}@${depFileUrl}${suffix ?? ''}`;
 }
 //# sourceMappingURL=createDeployFiles.js.map

package/lib/deploy/deploy.js

@@ -333,6 +333,11 @@ async function deployFromSharedLockfile(opts, selectedProject, deployDir) {
     const deployFiles = createDeployFiles({
         allProjects,
         deployDir,
+        include: {
+            dependencies: opts.production !== false,
+            devDependencies: opts.dev !== false,
+            optionalDependencies: opts.optional !== false,
+        },
         lockfile,
         lockfileDir,
         patchedDependencies: opts.patchedDependencies,

package/lib/index.d.ts

@@ -1,4 +1,6 @@
+export { change } from './change/index.js';
 export { deploy } from './deploy/index.js';
+export { lane } from './lane/index.js';
 export { packApp } from './pack-app/index.js';
 export { pack, publish } from './publish/index.js';
 export * as stage from './stage/index.js';

package/lib/index.js

@@ -1,4 +1,6 @@
+export { change } from './change/index.js';
 export { deploy } from './deploy/index.js';
+export { lane } from './lane/index.js';
 export { packApp } from './pack-app/index.js';
 export { pack, publish } from './publish/index.js';
 export * as stage from './stage/index.js';

package/lib/lane/index.d.ts

@@ -0,0 +1,24 @@
+import type { Config } from '@pnpm/config.reader';
+import type { Project, ProjectsGraph } from '@pnpm/types';
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const commandNames: string[];
+/**
+ * The reserved name of the default lane: every package is on it unless
+ * assigned elsewhere, packages on it release stable versions, and no
+ * prerelease lane can take the name.
+ */
+export declare const MAIN_LANE = "main";
+export declare function help(): string;
+export type LaneCommandOptions = Pick<Config, 'dir' | 'filter' | 'versioning' | 'workspaceDir'> & {
+    allProjects?: Project[];
+    selectedProjectsGraph?: ProjectsGraph;
+};
+export declare function handler(opts: LaneCommandOptions, params: string[]): Promise<string>;
+export declare const lane: {
+    handler: typeof handler;
+    help: typeof help;
+    commandNames: string[];
+    cliOptionsTypes: typeof cliOptionsTypes;
+    rcOptionsTypes: typeof rcOptionsTypes;
+};

package/lib/lane/index.js

@@ -0,0 +1,157 @@
+import { PnpmError } from '@pnpm/error';
+import { indexProjectRefs, toProjectDir } from '@pnpm/releasing.versioning';
+import { updateWorkspaceManifest } from '@pnpm/workspace.workspace-manifest-writer';
+import { renderHelp } from 'render-help';
+import { getReleasableProjects } from '../change/index.js';
+export function rcOptionsTypes() {
+    return {};
+}
+export function cliOptionsTypes() {
+    return {
+        recursive: Boolean,
+    };
+}
+export const commandNames = ['lane'];
+/**
+ * The reserved name of the default lane: every package is on it unless
+ * assigned elsewhere, packages on it release stable versions, and no
+ * prerelease lane can take the name.
+ */
+export const MAIN_LANE = 'main';
+export function help() {
+    return renderHelp({
+        description: 'Manages per-package release lanes. A lane is a parallel release track: while a package is on one, the bare "pnpm version -r" releases it as X.Y.Z-<lane>.N prereleases while the rest of the workspace keeps releasing stable versions. Moving a package back to the main lane releases its accumulated stable version on the next run. Membership lives under the versioning.lanes key of pnpm-workspace.yaml; this command is a convenience editor for that key.',
+        usages: [
+            'pnpm lane',
+            'pnpm lane <name> --filter <pattern>',
+            'pnpm lane main --filter <pattern>',
+        ],
+        descriptionLists: [
+            {
+                title: 'Options',
+                list: [
+                    {
+                        description: 'Select the packages to move between lanes',
+                        name: '--filter <pattern>',
+                    },
+                ],
+            },
+        ],
+    });
+}
+export async function handler(opts, params) {
+    const workspaceDir = opts.workspaceDir;
+    if (!workspaceDir) {
+        throw new PnpmError('WORKSPACE_ONLY', 'pnpm lane is only supported in a workspace');
+    }
+    if (params.length === 0) {
+        return renderLanes(opts.versioning?.lanes ?? {});
+    }
+    const laneName = params[0];
+    if ((opts.filter ?? []).length === 0) {
+        throw new PnpmError('VERSIONING_LANE_FILTER_REQUIRED', 'Select the packages to move with --filter, e.g. "pnpm lane alpha --filter <pkg>..."');
+    }
+    const refs = indexProjectRefs(opts.allProjects ?? [], workspaceDir);
+    const releasableDirs = new Set(getReleasableProjects(opts.allProjects ?? [], workspaceDir, opts.versioning).map((project) => project.dir));
+    const selected = Object.values(opts.selectedProjectsGraph ?? {})
+        .map((node) => ({
+        name: node.package.manifest.name,
+        dir: toProjectDir(workspaceDir, node.package.rootDir),
+    }))
+        .filter((project) => project.name != null && releasableDirs.has(project.dir));
+    if (selected.length === 0) {
+        throw new PnpmError('VERSIONING_NO_PACKAGES', 'The filter selected no releasable packages');
+    }
+    // Existing entries may reference projects by name or by directory; resolve
+    // them so assignments and removals key on the project, not the spelling.
+    const lanes = { ...opts.versioning?.lanes };
+    const laneByDir = new Map();
+    for (const [key, lane] of Object.entries(lanes)) {
+        for (const dir of refs.refToDirs(key)) {
+            laneByDir.set(dir, { key, lane });
+        }
+    }
+    let output;
+    if (laneName === MAIN_LANE) {
+        for (const project of selected) {
+            const existing = laneByDir.get(project.dir);
+            if (existing != null) {
+                delete lanes[existing.key];
+            }
+        }
+        output = `Moved to the main lane:\n${selected.map((project) => `  ${refFor(project, refs)}\n`).join('')}` +
+            'The accumulated stable versions release on the next "pnpm version -r" run.';
+    }
+    else {
+        if (laneName.toLowerCase() === MAIN_LANE) {
+            throw new PnpmError('VERSIONING_INVALID_LANE_NAME', `Invalid lane name: ${laneName}. "main" is the reserved default lane; spell it in lowercase to move packages back onto it.`);
+        }
+        // A purely numeric lane name is rejected because semver parses an
+        // all-digit prerelease identifier as a number, which changes sorting
+        // semantics.
+        if (!/^[0-9A-Z-]+$/i.test(laneName) || /^\d+$/.test(laneName)) {
+            throw new PnpmError('VERSIONING_INVALID_LANE_NAME', `Invalid lane name: ${laneName}. Lane names may contain only alphanumerics and hyphens, and cannot be purely numeric.`);
+        }
+        for (const project of selected) {
+            const existing = laneByDir.get(project.dir);
+            if (existing != null && existing.lane !== laneName) {
+                throw new PnpmError('VERSIONING_ALREADY_ON_LANE', `${refFor(project, refs)} is already on the "${existing.lane}" lane. Move it back with "pnpm lane main" first.`);
+            }
+            if (existing == null) {
+                lanes[refFor(project, refs)] = laneName;
+            }
+        }
+        output = `Moved to the "${laneName}" lane:\n${selected.map((project) => `  ${refFor(project, refs)}\n`).join('')}`;
+    }
+    const versioning = { ...opts.versioning };
+    if (Object.keys(lanes).length > 0) {
+        versioning.lanes = lanes;
+    }
+    else {
+        delete versioning.lanes;
+    }
+    await updateWorkspaceManifest(workspaceDir, {
+        updatedFields: {
+            versioning: Object.keys(versioning).length > 0 ? versioning : undefined,
+        },
+    });
+    return output;
+}
+/**
+ * How the project is referenced in versioning.lanes and in output: the bare
+ * name, or the directory path when the name is shared by several projects.
+ */
+function refFor(project, refs) {
+    return refs.nameToDirs(project.name).length > 1 ? `./${project.dir}` : project.name;
+}
+function renderLanes(lanes) {
+    const laneEntries = Object.entries(lanes);
+    if (laneEntries.length === 0) {
+        return 'All packages are on the main lane.';
+    }
+    const byLane = new Map();
+    for (const [ref, laneName] of laneEntries) {
+        let members = byLane.get(laneName);
+        if (members == null) {
+            members = [];
+            byLane.set(laneName, members);
+        }
+        members.push(ref);
+    }
+    let output = 'Lanes:\n';
+    for (const [laneName, members] of Array.from(byLane.entries()).sort(([left], [right]) => left.localeCompare(right))) {
+        output += `  ${laneName}:\n`;
+        for (const ref of members.sort()) {
+            output += `    ${ref}\n`;
+        }
+    }
+    return output;
+}
+export const lane = {
+    handler,
+    help,
+    commandNames,
+    cliOptionsTypes,
+    rcOptionsTypes,
+};
+//# sourceMappingURL=index.js.map

package/lib/publish/batchPublish.js

@@ -135,7 +135,7 @@ async function multiPublishToRegistry(registry, group, opts) {
             operation: async (otp) => npmFetch(BATCH_PUBLISH_ENDPOINT, {
                 ...publishOptions,
                 access: publishOptions.access ?? undefined,
-                otp,
+                otp: otp ?? publishOptions.otp,
                 method: 'PUT',
                 body,
                 ignoreBody: true,

package/lib/publish/extractManifestFromPacked.d.ts

@@ -5,6 +5,13 @@ export type TarballSuffix = typeof TARBALL_SUFFIXES[number];
 export type TarballPath = `${string}${TarballSuffix}`;
 export declare const isTarballPath: (path: string) => path is TarballPath;
 export declare function extractManifestFromPacked<Output = ExportedManifest>(tarballPath: TarballPath): Promise<Output>;
+/**
+ * Read the publish manifest from a pre-built tarball, filling in its `readme` from the tarball's
+ * root README file when the manifest doesn't already declare one. This mirrors the npm CLI, which
+ * reads the readme out of the tarball (via pacote's `fullReadJson`) so the registry gets it as
+ * metadata even though it isn't stored in the packed `package.json`.
+ */
+export declare function extractPublishManifestFromPacked(tarballPath: TarballPath): Promise<ExportedManifest>;
 export declare class PublishArchiveMissingManifestError extends PnpmError {
     readonly tarballPath: string;
     constructor(tarballPath: string);