@pnpm/releasing.commands 1100.7.0 → 1100.8.0

package/lib/deploy/deploy.js

@@ -0,0 +1,398 @@
+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 { isSubdir } from 'is-subdir';
+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 const overridableByScript = true;
+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);
+    validateDeployTarget(deployDir, {
+        dir: opts.dir,
+        force: opts.force,
+        projectDir: selectedProject.rootDir,
+        workspaceDir: opts.workspaceDir,
+    });
+    const normalizedDeployDir = path.resolve(deployDir);
+    const normalizedWorkspaceDir = path.resolve(opts.workspaceDir);
+    const workspaceChildTarget = isChildPath(normalizedDeployDir, normalizedWorkspaceDir);
+    if (workspaceChildTarget) {
+        createWorkspaceChildTargetParents(normalizedWorkspaceDir, normalizedDeployDir);
+    }
+    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 });
+    }
+    if (workspaceChildTarget) {
+        validateWorkspaceChildTargetComponents(normalizedWorkspaceDir, normalizedDeployDir);
+    }
+    await rimraf(deployDir);
+    if (workspaceChildTarget) {
+        createWorkspaceChildTargetParents(normalizedWorkspaceDir, normalizedDeployDir);
+        createWorkspaceChildTargetDir(normalizedWorkspaceDir, normalizedDeployDir);
+    }
+    else {
+        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')),
+        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' });
+}
+function validateDeployTarget(deployDir, opts) {
+    const normalizedDeployDir = path.resolve(deployDir);
+    const workspaceDir = path.resolve(opts.workspaceDir);
+    const projectDir = path.resolve(opts.projectDir);
+    const dir = path.resolve(opts.dir);
+    if (samePath(normalizedDeployDir, workspaceDir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target is the workspace root');
+    }
+    if (isAncestorPath(normalizedDeployDir, workspaceDir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the workspace root');
+    }
+    if (samePath(normalizedDeployDir, projectDir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target is the selected project root');
+    }
+    if (isAncestorPath(normalizedDeployDir, projectDir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the selected project');
+    }
+    if (samePath(normalizedDeployDir, dir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target is the current directory');
+    }
+    if (isAncestorPath(normalizedDeployDir, dir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target contains the current directory');
+    }
+    if (opts.force && !isChildPath(normalizedDeployDir, workspaceDir)) {
+        throw unsafeDeployTarget(normalizedDeployDir, 'target is outside the workspace');
+    }
+    if (isChildPath(normalizedDeployDir, workspaceDir)) {
+        validateWorkspaceChildTargetComponents(workspaceDir, normalizedDeployDir);
+    }
+}
+function validateWorkspaceChildTargetComponents(workspaceDir, deployDir) {
+    const relative = path.relative(workspaceDir, deployDir);
+    let current = workspaceDir;
+    for (const component of relative.split(path.sep)) {
+        if (!component)
+            continue;
+        current = path.join(current, component);
+        let stat;
+        try {
+            stat = fs.lstatSync(current);
+        }
+        catch (error) {
+            if (isENOENT(error))
+                return;
+            throw error;
+        }
+        if (stat.isSymbolicLink()) {
+            throw unsafeDeployTarget(current, 'target path contains a symlink');
+        }
+    }
+}
+function createWorkspaceChildTargetParents(workspaceDir, deployDir) {
+    const parent = path.dirname(deployDir);
+    const relative = path.relative(workspaceDir, parent);
+    let current = workspaceDir;
+    for (const component of relative.split(path.sep)) {
+        if (!component)
+            continue;
+        current = path.join(current, component);
+        createWorkspaceChildTargetComponent(current);
+    }
+}
+function createWorkspaceChildTargetDir(workspaceDir, deployDir) {
+    try {
+        fs.mkdirSync(deployDir);
+    }
+    catch (error) {
+        if (isEEXIST(error)) {
+            throw unsafeDeployTarget(deployDir, 'target changed during deploy preparation');
+        }
+        throw error;
+    }
+    validateWorkspaceChildTargetComponents(workspaceDir, deployDir);
+}
+function createWorkspaceChildTargetComponent(component) {
+    try {
+        fs.mkdirSync(component);
+    }
+    catch (error) {
+        if (!isEEXIST(error))
+            throw error;
+    }
+    const stat = fs.lstatSync(component);
+    if (stat.isSymbolicLink()) {
+        throw unsafeDeployTarget(component, 'target path contains a symlink');
+    }
+    if (!stat.isDirectory()) {
+        throw unsafeDeployTarget(component, 'target path contains a non-directory');
+    }
+}
+function unsafeDeployTarget(deployDir, reason) {
+    return new PnpmError('INVALID_DEPLOY_TARGET', `Refusing to deploy to unsafe target ${deployDir}: ${reason}`);
+}
+function samePath(left, right) {
+    return path.normalize(left) === path.normalize(right);
+}
+function isAncestorPath(parent, child) {
+    return isChildPath(child, parent);
+}
+function isChildPath(child, parent) {
+    return !samePath(child, parent) && isSubdir(parent, child);
+}
+function isENOENT(error) {
+    return typeof error === 'object' && error != null && 'code' in error && error.code === 'ENOENT';
+}
+function isEEXIST(error) {
+    return typeof error === 'object' && error != null && 'code' in error && error.code === 'EEXIST';
+}
+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,
+        include: {
+            dependencies: opts.production !== false,
+            devDependencies: opts.dev !== false,
+            optionalDependencies: opts.optional !== false,
+        },
+        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
+            configDependencies: undefined, // configDependencies (e.g. pacquet) are not installed into the deploy dir, so the install engine they designate isn't on disk to invoke
+            hooks: {
+                ...opts.hooks,
+                readPackage: [
+                    ...(opts.hooks?.readPackage ?? []),
+                    deployHook,
+                ],
+                calculatePnpmfileChecksum: undefined, // the effects of the pnpmfile should already be part of the package snapshots
+            },
+        });
+    }
+    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,7 @@
+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';
+export { version } from './version/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/pack-app/index.d.ts

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

package/lib/pack-app/index.js

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

package/lib/pack-app/packApp.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '@pnpm/config.reader';
+export declare const commandNames: string[];
+export declare function rcOptionsTypes(): Record<string, unknown>;
+export declare function cliOptionsTypes(): Record<string, unknown>;
+export declare const shorthands: Record<string, string>;
+export declare function help(): string;
+export type PackAppOptions = Pick<Config, 'dir' | 'pnpmHomeDir'> & Partial<Pick<Config, 'ca' | 'cert' | 'configByUri' | 'httpProxy' | 'httpsProxy' | 'key' | 'localAddress' | 'nodeDownloadMirrors' | 'noProxy' | 'strictSsl' | 'userAgent'>> & {
+    entry?: string;
+    target?: string | string[];
+    runtime?: string;
+    outputDir?: string;
+    outputName?: string;
+};
+export declare function handler(opts: PackAppOptions, params: string[]): Promise<string>;
+/** Fields pack-app reads from `pnpm.app` in package.json. */
+export interface ProjectAppConfig {
+    entry?: string;
+    targets?: string[];
+    runtime?: string;
+    outputDir?: string;
+    outputName?: string;
+}