@pnpm/releasing.commands 1100.6.0 → 1100.6.1

package/lib/deploy/createDeployFiles.js

@@ -1,255 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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>;

package/lib/deploy/deploy.js

@@ -1,398 +0,0 @@
-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

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

package/lib/deploy/deployHook.js

@@ -1,15 +0,0 @@
-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