@pnpm/releasing.commands 1100.5.5 → 1100.6.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @pnpm/releasing.commands
 
+## 1100.6.0
+
+### Minor Changes
+
+- Added native workspace release management [#12952](https://github.com/pnpm/pnpm/issues/12952): the new `pnpm change` command records change intents as changesets-compatible `.changeset/*.md` files (`pnpm change status` shows the pending release plan), and the bare `pnpm version -r` consumes them — bumping versions across the workspace with dependent propagation through `workspace:` ranges, fixed groups, a `maxBump` cap, `--filter` narrowing, and `--dry-run` — writing changelogs, and recording consumed intents in a committed ledger that keeps cherry-picks and merge-backs between release branches safe. Packages can be moved onto per-package release lanes with the new `pnpm lane <name> --filter <pkg>` command and back with `pnpm lane main --filter <pkg>` (`pnpm lane` shows the membership), releasing `X.Y.Z-lane.N` prereleases from the same runs that release stable versions of the packages on the main lane. Configuration lives under the new `versioning` key of `pnpm-workspace.yaml` (`fixed`, `ignore`, `maxBump`, `lanes`, `changelog`). When two workspace projects publish the same name, intent files, `versioning.lanes`, and `versioning.fixed`/`ignore` may reference a project by its workspace-relative directory path (e.g. `"./pnpm/npm/pnpm"`) — the one additive extension to the changesets format, applied automatically by `pnpm change`.
+
+  Release changelogs default to `registry` storage (`versioning.changelog.storage`): no `CHANGELOG.md` is committed. Each release's section is composed at publish time and packed into the published tarball on top of the previously published version's changelog, and the consumed change intents are garbage-collected by a later `pnpm version -r` only once the registry confirms the version is published with its section. Set `versioning.changelog.storage: repository` to keep committed `CHANGELOG.md` files instead.
+
+### Patch Changes
+
+- `pnpm deploy` now supports workspaces that use catalogs.
+
+- Fixed `pnpm deploy` with a shared lockfile so local `file:` tarball dependencies keep their package name in the generated deploy lockfile. This prevents warm-store deploys from failing with `ERR_PNPM_UNEXPECTED_PKG_CONTENT_IN_STORE` when the tarball filename includes the version.
+
+- Fixed `pnpm publish --otp` and `pnpm publish --batch --otp` to send the configured OTP to the registry.
+
+- `pnpm publish` again sends the package's README to the registry as metadata, so registries can render it on the package page. The readme is always included in the published metadata (matching the npm CLI), while the `embed-readme` setting continues to control only whether the readme is written into the `package.json` inside the tarball. This restores the behavior that was lost when publishing became fully native. Closes pnpm/pnpm#12966.
+
+- Limit modern deploy lockfiles and localized virtual stores to dependencies reachable from the selected dependency groups.
+
+- `pnpm pack` now respects workspace-root `.npmignore` and `.gitignore` files when packing workspace packages.
+
+- Updated dependencies:
+  - @pnpm/bins.resolver@1100.0.9
+  - @pnpm/cli.utils@1101.0.14
+  - @pnpm/config.pick-registry-for-package@1100.0.10
+  - @pnpm/config.reader@1101.12.0
+  - @pnpm/deps.path@1100.0.9
+  - @pnpm/engine.runtime.commands@1100.1.11
+  - @pnpm/engine.runtime.node-resolver@1101.1.13
+  - @pnpm/exec.lifecycle@1100.1.3
+  - @pnpm/fetching.directory-fetcher@1100.0.20
+  - @pnpm/fs.indexed-pkg-importer@1100.0.18
+  - @pnpm/fs.packlist@1100.0.2
+  - @pnpm/installing.client@1100.2.14
+  - @pnpm/installing.commands@1100.10.5
+  - @pnpm/lockfile.fs@1100.1.11
+  - @pnpm/lockfile.types@1100.0.14
+  - @pnpm/network.auth-header@1101.1.4
+  - @pnpm/network.fetch@1100.1.5
+  - @pnpm/releasing.exportable-manifest@1100.1.10
+  - @pnpm/releasing.versioning@1100.1.0
+  - @pnpm/resolving.npm-resolver@1102.1.3
+  - @pnpm/resolving.registry.types@1100.1.4
+  - @pnpm/resolving.resolver-base@1100.5.2
+  - @pnpm/types@1101.4.0
+  - @pnpm/workspace.projects-filter@1100.0.27
+  - @pnpm/workspace.projects-sorter@1100.0.9
+  - @pnpm/workspace.workspace-manifest-writer@1100.0.16
+
 ## 1100.5.5
 
 ### Patch Changes

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;
+};