@pnpm/building.after-install 1000.0.0-0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @pnpm/building.after-install
+
+> Rebuild packages that are already installed by running their lifecycle scripts
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/building.after-install.svg)](https://www.npmjs.com/package/@pnpm/building.after-install)
+<!--/@-->
+
+## Installation
+
+```sh
+pnpm add @pnpm/building.after-install
+```
+
+## License
+
+MIT

package/lib/extendBuildOptions.d.ts

@@ -0,0 +1,51 @@
+import { type Config } from '@pnpm/config';
+import type { LogBase } from '@pnpm/logger';
+import type { StoreController } from '@pnpm/store-controller-types';
+import type { Registries } from '@pnpm/types';
+export type StrictBuildOptions = {
+    autoInstallPeers: boolean;
+    cacheDir: string;
+    childConcurrency: number;
+    excludeLinksFromLockfile: boolean;
+    extraBinPaths: string[];
+    extraEnv: Record<string, string>;
+    lockfileDir: string;
+    nodeLinker: 'isolated' | 'hoisted' | 'pnp';
+    preferSymlinkedExecutables?: boolean;
+    scriptShell?: string;
+    sideEffectsCacheRead: boolean;
+    sideEffectsCacheWrite: boolean;
+    scriptsPrependNodePath: boolean | 'warn-only';
+    shellEmulator: boolean;
+    skipIfHasSideEffectsCache?: boolean;
+    storeDir: string;
+    storeController: StoreController;
+    force: boolean;
+    useLockfile: boolean;
+    registries: Registries;
+    dir: string;
+    pnpmHomeDir: string;
+    reporter: (logObj: LogBase) => void;
+    production: boolean;
+    development: boolean;
+    optional: boolean;
+    rawConfig: object;
+    userConfig: Record<string, string>;
+    userAgent: string;
+    packageManager: {
+        name: string;
+        version: string;
+    };
+    unsafePerm: boolean;
+    pending: boolean;
+    shamefullyHoist: boolean;
+    deployAllFiles: boolean;
+    neverBuiltDependencies?: string[];
+    allowBuilds?: Record<string, boolean | string>;
+    virtualStoreDirMaxLength: number;
+    peersSuffixMaxLength: number;
+    strictStorePkgContentCheck: boolean;
+    fetchFullMetadata?: boolean;
+} & Pick<Config, 'sslConfigs' | 'allowBuilds'>;
+export type BuildOptions = Partial<StrictBuildOptions> & Pick<StrictBuildOptions, 'storeDir' | 'storeController'> & Pick<Config, 'rootProjectManifest' | 'rootProjectManifestDir'>;
+export declare function extendBuildOptions(opts: BuildOptions): Promise<StrictBuildOptions>;

package/lib/extendBuildOptions.js

@@ -0,0 +1,54 @@
+import path from 'path';
+import { getOptionsFromRootManifest } from '@pnpm/config';
+import { normalizeRegistries, DEFAULT_REGISTRIES } from '@pnpm/normalize-registries';
+import { loadJsonFile } from 'load-json-file';
+const defaults = async (opts) => {
+    const packageManager = opts.packageManager ??
+        await loadJsonFile(path.join(import.meta.dirname, '../package.json'));
+    const dir = opts.dir ?? process.cwd();
+    const lockfileDir = opts.lockfileDir ?? dir;
+    return {
+        childConcurrency: 5,
+        development: true,
+        dir,
+        force: false,
+        lockfileDir,
+        nodeLinker: 'isolated',
+        optional: true,
+        packageManager,
+        pending: false,
+        production: true,
+        rawConfig: {},
+        registries: DEFAULT_REGISTRIES,
+        scriptsPrependNodePath: false,
+        shamefullyHoist: false,
+        shellEmulator: false,
+        sideEffectsCacheRead: false,
+        storeDir: opts.storeDir,
+        unsafePerm: process.platform === 'win32' ||
+            process.platform === 'cygwin' ||
+            !process.setgid ||
+            process.getuid?.() !== 0,
+        useLockfile: true,
+        userAgent: `${packageManager.name}/${packageManager.version} npm/? node/${process.version} ${process.platform} ${process.arch}`,
+    };
+};
+export async function extendBuildOptions(opts) {
+    if (opts) {
+        for (const key in opts) {
+            if (opts[key] === undefined) {
+                delete opts[key];
+            }
+        }
+    }
+    const defaultOpts = await defaults(opts);
+    const extendedOpts = {
+        ...defaultOpts,
+        ...opts,
+        storeDir: defaultOpts.storeDir,
+        ...(opts.rootProjectManifest ? getOptionsFromRootManifest(opts.rootProjectManifestDir, opts.rootProjectManifest) : {}),
+    };
+    extendedOpts.registries = normalizeRegistries(extendedOpts.registries);
+    return extendedOpts;
+}
+//# sourceMappingURL=extendBuildOptions.js.map

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import type { IgnoredBuilds, ProjectManifest, ProjectRootDir } from '@pnpm/types';
+import { type BuildOptions } from './extendBuildOptions.js';
+export type { BuildOptions };
+export declare function buildSelectedPkgs(projects: Array<{
+    buildIndex: number;
+    manifest: ProjectManifest;
+    rootDir: ProjectRootDir;
+}>, pkgSpecs: string[], maybeOpts: BuildOptions): Promise<{
+    ignoredBuilds?: IgnoredBuilds;
+}>;
+export declare function buildProjects(projects: Array<{
+    buildIndex: number;
+    manifest: ProjectManifest;
+    rootDir: ProjectRootDir;
+}>, maybeOpts: BuildOptions): Promise<void>;

package/lib/index.js

@@ -0,0 +1,369 @@
+import assert from 'assert';
+import path from 'path';
+import util from 'util';
+import { pkgRequiresBuild } from '@pnpm/building.pkg-requires-build';
+import { createAllowBuildFunction } from '@pnpm/building.policy';
+import { calcDepState, lockfileToDepGraph } from '@pnpm/calc-dep-state';
+import { LAYOUT_VERSION, WANTED_LOCKFILE, } from '@pnpm/constants';
+import { skippedOptionalDependencyLogger } from '@pnpm/core-loggers';
+import * as dp from '@pnpm/dependency-path';
+import { graphSequencer } from '@pnpm/deps.graph-sequencer';
+import { PnpmError } from '@pnpm/error';
+import { getContext } from '@pnpm/get-context';
+import { runLifecycleHooksConcurrently, runPostinstallHooks, } from '@pnpm/lifecycle';
+import { linkBins } from '@pnpm/link-bins';
+import { nameVerFromPkgSnapshot, packageIsIndependent, } from '@pnpm/lockfile.utils';
+import { lockfileWalker } from '@pnpm/lockfile.walker';
+import { logger, streamParser } from '@pnpm/logger';
+import { writeModulesManifest } from '@pnpm/modules-yaml';
+import npa from '@pnpm/npm-package-arg';
+import { safeReadPackageJsonFromDir } from '@pnpm/read-package-json';
+import { StoreIndex, storeIndexKey } from '@pnpm/store.index';
+import { createStoreController } from '@pnpm/store-connection-manager';
+import { hardLinkDir } from '@pnpm/worker';
+import pLimit from 'p-limit';
+import { runGroups } from 'run-groups';
+import semver from 'semver';
+import { extendBuildOptions, } from './extendBuildOptions.js';
+function findPackages(packages, searched, opts) {
+    return Object.keys(packages)
+        .filter((relativeDepPath) => {
+        const pkgLockfile = packages[relativeDepPath];
+        const pkgInfo = nameVerFromPkgSnapshot(relativeDepPath, pkgLockfile);
+        if (!pkgInfo.name) {
+            logger.warn({
+                message: `Skipping ${relativeDepPath} because cannot get the package name from ${WANTED_LOCKFILE}.
+            Try to run \`pnpm update --depth 100\` to create a new ${WANTED_LOCKFILE} with all the necessary info.`,
+                prefix: opts.prefix,
+            });
+            return false;
+        }
+        return matches(searched, pkgInfo);
+    });
+}
+// TODO: move this logic to separate package as this is also used in dependencies-hierarchy
+function matches(searched, manifest) {
+    return searched.some((searchedPkg) => {
+        if (typeof searchedPkg === 'string') {
+            return manifest.name === searchedPkg;
+        }
+        return searchedPkg.name === manifest.name && !!manifest.version &&
+            semver.satisfies(manifest.version, searchedPkg.range);
+    });
+}
+export async function buildSelectedPkgs(projects, pkgSpecs, maybeOpts) {
+    const reporter = maybeOpts?.reporter;
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.on('data', reporter);
+    }
+    const opts = await extendBuildOptions(maybeOpts);
+    const ctx = await getContext({ ...opts, allProjects: projects });
+    if (ctx.currentLockfile?.packages == null)
+        return {};
+    const packages = ctx.currentLockfile.packages;
+    const searched = pkgSpecs.map((arg) => {
+        const { fetchSpec, name, raw, type } = npa(arg);
+        if (raw === name) {
+            return name;
+        }
+        if (type !== 'version' && type !== 'range') {
+            throw new Error(`Invalid argument - ${arg}. Rebuild can only select by version or range`);
+        }
+        return {
+            name,
+            range: fetchSpec,
+        };
+    });
+    let pkgs = [];
+    for (const { rootDir } of projects) {
+        pkgs = [
+            ...pkgs,
+            ...findPackages(packages, searched, { prefix: rootDir }),
+        ];
+    }
+    const { ignoredPkgs } = await _rebuild({
+        pkgsToRebuild: new Set(pkgs),
+        ...ctx,
+    }, opts);
+    await writeModulesManifest(ctx.rootModulesDir, {
+        prunedAt: new Date().toUTCString(),
+        ...ctx.modulesFile,
+        hoistedDependencies: ctx.hoistedDependencies,
+        hoistPattern: ctx.hoistPattern,
+        included: ctx.include,
+        ignoredBuilds: ignoredPkgs,
+        layoutVersion: LAYOUT_VERSION,
+        packageManager: `${opts.packageManager.name}@${opts.packageManager.version}`,
+        pendingBuilds: ctx.pendingBuilds,
+        publicHoistPattern: ctx.publicHoistPattern,
+        registries: ctx.registries,
+        skipped: Array.from(ctx.skipped),
+        storeDir: ctx.storeDir,
+        virtualStoreDir: ctx.virtualStoreDir,
+        virtualStoreDirMaxLength: ctx.virtualStoreDirMaxLength,
+    });
+    return {
+        ignoredBuilds: ignoredPkgs,
+    };
+}
+export async function buildProjects(projects, maybeOpts) {
+    const reporter = maybeOpts?.reporter;
+    if ((reporter != null) && typeof reporter === 'function') {
+        streamParser.on('data', reporter);
+    }
+    const opts = await extendBuildOptions(maybeOpts);
+    const ctx = await getContext({ ...opts, allProjects: projects });
+    let idsToRebuild = [];
+    if (opts.pending) {
+        idsToRebuild = ctx.pendingBuilds;
+    }
+    else if ((ctx.currentLockfile?.packages) != null) {
+        idsToRebuild = Object.keys(ctx.currentLockfile.packages);
+    }
+    const { pkgsThatWereRebuilt, ignoredPkgs } = await _rebuild({
+        pkgsToRebuild: new Set(idsToRebuild),
+        ...ctx,
+    }, opts);
+    ctx.pendingBuilds = ctx.pendingBuilds.filter((depPath) => !pkgsThatWereRebuilt.has(depPath));
+    const store = await createStoreController(opts);
+    const scriptsOpts = {
+        extraBinPaths: ctx.extraBinPaths,
+        extraNodePaths: ctx.extraNodePaths,
+        extraEnv: opts.extraEnv,
+        preferSymlinkedExecutables: opts.preferSymlinkedExecutables,
+        rawConfig: opts.rawConfig,
+        scriptsPrependNodePath: opts.scriptsPrependNodePath,
+        scriptShell: opts.scriptShell,
+        shellEmulator: opts.shellEmulator,
+        storeController: store.ctrl,
+        unsafePerm: opts.unsafePerm || false,
+    };
+    await runLifecycleHooksConcurrently(['preinstall', 'install', 'postinstall', 'prepublish', 'prepare'], Object.values(ctx.projects), opts.childConcurrency || 5, scriptsOpts);
+    for (const { id, manifest } of Object.values(ctx.projects)) {
+        if (((manifest?.scripts) != null) && (!opts.pending || ctx.pendingBuilds.includes(id))) {
+            ctx.pendingBuilds.splice(ctx.pendingBuilds.indexOf(id), 1);
+        }
+    }
+    await writeModulesManifest(ctx.rootModulesDir, {
+        prunedAt: new Date().toUTCString(),
+        ...ctx.modulesFile,
+        hoistedDependencies: ctx.hoistedDependencies,
+        hoistPattern: ctx.hoistPattern,
+        included: ctx.include,
+        ignoredBuilds: ignoredPkgs,
+        layoutVersion: LAYOUT_VERSION,
+        packageManager: `${opts.packageManager.name}@${opts.packageManager.version}`,
+        pendingBuilds: ctx.pendingBuilds,
+        publicHoistPattern: ctx.publicHoistPattern,
+        registries: ctx.registries,
+        skipped: Array.from(ctx.skipped),
+        storeDir: ctx.storeDir,
+        virtualStoreDir: ctx.virtualStoreDir,
+        virtualStoreDirMaxLength: ctx.virtualStoreDirMaxLength,
+    });
+}
+function getSubgraphToBuild(step, nodesToBuildAndTransitive, opts) {
+    let currentShouldBeBuilt = false;
+    for (const { depPath, next } of step.dependencies) {
+        if (nodesToBuildAndTransitive.has(depPath)) {
+            currentShouldBeBuilt = true;
+        }
+        const childShouldBeBuilt = getSubgraphToBuild(next(), nodesToBuildAndTransitive, opts) ||
+            opts.pkgsToRebuild.has(depPath);
+        if (childShouldBeBuilt) {
+            nodesToBuildAndTransitive.add(depPath);
+            currentShouldBeBuilt = true;
+        }
+    }
+    for (const depPath of step.missing) {
+        // It might make sense to fail if the depPath is not in the skipped list from .modules.yaml
+        // However, the skipped list currently contains package IDs, not dep paths.
+        logger.debug({ message: `No entry for "${depPath}" in ${WANTED_LOCKFILE}` });
+    }
+    return currentShouldBeBuilt;
+}
+const limitLinking = pLimit(16);
+async function _rebuild(ctx, opts) {
+    const depGraph = lockfileToDepGraph(ctx.currentLockfile);
+    const depsStateCache = {};
+    const pkgsThatWereRebuilt = new Set();
+    const graph = new Map();
+    const pkgSnapshots = ctx.currentLockfile.packages ?? {};
+    const nodesToBuildAndTransitive = new Set();
+    getSubgraphToBuild(lockfileWalker(ctx.currentLockfile, Object.values(ctx.projects).map(({ id }) => id), {
+        include: {
+            dependencies: opts.production,
+            devDependencies: opts.development,
+            optionalDependencies: opts.optional,
+        },
+    }).step, nodesToBuildAndTransitive, { pkgsToRebuild: ctx.pkgsToRebuild });
+    const nodesToBuildAndTransitiveArray = Array.from(nodesToBuildAndTransitive);
+    for (const depPath of nodesToBuildAndTransitiveArray) {
+        const pkgSnapshot = pkgSnapshots[depPath];
+        graph.set(depPath, Object.entries({ ...pkgSnapshot.dependencies, ...pkgSnapshot.optionalDependencies })
+            .map(([pkgName, reference]) => dp.refToRelative(reference, pkgName))
+            .filter((childRelDepPath) => childRelDepPath && nodesToBuildAndTransitive.has(childRelDepPath)));
+    }
+    const graphSequencerResult = graphSequencer(graph, nodesToBuildAndTransitiveArray);
+    const chunks = graphSequencerResult.chunks;
+    const warn = (message) => {
+        logger.info({ message, prefix: opts.dir });
+    };
+    const ignoredPkgs = new Set();
+    const _allowBuild = createAllowBuildFunction(opts) ?? (() => undefined);
+    const allowBuild = (pkgName, version, depPath) => {
+        switch (_allowBuild(pkgName, version)) {
+            case true: return true;
+            case undefined: {
+                ignoredPkgs.add(depPath);
+                break;
+            }
+        }
+        return false;
+    };
+    const builtDepPaths = new Set();
+    const storeIndex = opts.skipIfHasSideEffectsCache ? new StoreIndex(opts.storeDir) : undefined;
+    const groups = chunks.map((chunk) => chunk.filter((depPath) => ctx.pkgsToRebuild.has(depPath) && !ctx.skipped.has(depPath)).map((depPath) => async () => {
+        const pkgSnapshot = pkgSnapshots[depPath];
+        const pkgInfo = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
+        const pkgRoots = opts.nodeLinker === 'hoisted'
+            ? (ctx.modulesFile?.hoistedLocations?.[depPath] ?? []).map((hoistedLocation) => path.join(opts.lockfileDir, hoistedLocation))
+            : [path.join(ctx.virtualStoreDir, dp.depPathToFilename(depPath, opts.virtualStoreDirMaxLength), 'node_modules', pkgInfo.name)];
+        if (pkgRoots.length === 0) {
+            if (pkgSnapshot.optional)
+                return;
+            throw new PnpmError('MISSING_HOISTED_LOCATIONS', `${depPath} is not found in hoistedLocations inside node_modules/.modules.yaml`, {
+                hint: 'If you installed your node_modules with pnpm older than v7.19.0, you may need to remove it and run "pnpm install"',
+            });
+        }
+        const pkgRoot = pkgRoots[0];
+        try {
+            const extraBinPaths = ctx.extraBinPaths;
+            if (opts.nodeLinker !== 'hoisted') {
+                const modules = path.join(ctx.virtualStoreDir, dp.depPathToFilename(depPath, opts.virtualStoreDirMaxLength), 'node_modules');
+                const binPath = path.join(pkgRoot, 'node_modules', '.bin');
+                await linkBins(modules, binPath, { extraNodePaths: ctx.extraNodePaths, warn });
+            }
+            else {
+                extraBinPaths.push(...binDirsInAllParentDirs(pkgRoot, opts.lockfileDir));
+            }
+            const resolution = pkgSnapshot.resolution;
+            let sideEffectsCacheKey;
+            const pkgId = `${pkgInfo.name}@${pkgInfo.version}`;
+            if (opts.skipIfHasSideEffectsCache && resolution.integrity) {
+                const filesIndexFile = storeIndexKey(resolution.integrity.toString(), pkgId);
+                const pkgFilesIndex = storeIndex.get(filesIndexFile);
+                if (pkgFilesIndex) {
+                    sideEffectsCacheKey = calcDepState(depGraph, depsStateCache, depPath, {
+                        includeDepGraphHash: true,
+                    });
+                    if (pkgFilesIndex.sideEffects?.has(sideEffectsCacheKey)) {
+                        pkgsThatWereRebuilt.add(depPath);
+                        return;
+                    }
+                }
+            }
+            let requiresBuild = true;
+            const pgkManifest = await safeReadPackageJsonFromDir(pkgRoot);
+            if (pgkManifest != null) {
+                // This won't return the correct result for packages with binding.gyp as we don't pass the filesIndex to the function.
+                // However, currently rebuild doesn't work for such packages at all, which should be fixed.
+                requiresBuild = pkgRequiresBuild(pgkManifest, new Map());
+            }
+            const hasSideEffects = requiresBuild && allowBuild(pkgInfo.name, pkgInfo.version, depPath) && await runPostinstallHooks({
+                depPath,
+                extraBinPaths,
+                extraEnv: opts.extraEnv,
+                optional: pkgSnapshot.optional === true,
+                pkgRoot,
+                rawConfig: opts.rawConfig,
+                rootModulesDir: ctx.rootModulesDir,
+                scriptsPrependNodePath: opts.scriptsPrependNodePath,
+                shellEmulator: opts.shellEmulator,
+                unsafePerm: opts.unsafePerm || false,
+            });
+            if (hasSideEffects && (opts.sideEffectsCacheWrite ?? true) && resolution.integrity) {
+                builtDepPaths.add(depPath);
+                const filesIndexFile = storeIndexKey(resolution.integrity.toString(), pkgId);
+                try {
+                    if (!sideEffectsCacheKey) {
+                        sideEffectsCacheKey = calcDepState(depGraph, depsStateCache, depPath, {
+                            includeDepGraphHash: true,
+                        });
+                    }
+                    await opts.storeController.upload(pkgRoot, {
+                        sideEffectsCacheKey,
+                        filesIndexFile,
+                    });
+                }
+                catch (err) {
+                    assert(util.types.isNativeError(err));
+                    logger.warn({
+                        error: err,
+                        message: `An error occurred while uploading ${pkgRoot}`,
+                        prefix: opts.lockfileDir,
+                    });
+                }
+            }
+            pkgsThatWereRebuilt.add(depPath);
+        }
+        catch (err) {
+            assert(util.types.isNativeError(err));
+            if (pkgSnapshot.optional) {
+                // TODO: add parents field to the log
+                skippedOptionalDependencyLogger.debug({
+                    details: err.toString(),
+                    package: {
+                        id: pkgSnapshot.id ?? depPath,
+                        name: pkgInfo.name,
+                        version: pkgInfo.version,
+                    },
+                    prefix: opts.dir,
+                    reason: 'build_failure',
+                });
+                return;
+            }
+            throw err;
+        }
+        if (pkgRoots.length > 1) {
+            await hardLinkDir(pkgRoot, pkgRoots.slice(1));
+        }
+    }));
+    await runGroups(opts.childConcurrency || 5, groups);
+    storeIndex?.close();
+    if (builtDepPaths.size > 0) {
+        // It may be optimized because some bins were already linked before running lifecycle scripts
+        await Promise.all(Object
+            .keys(pkgSnapshots)
+            .filter((depPath) => !packageIsIndependent(pkgSnapshots[depPath]))
+            .map(async (depPath) => limitLinking(async () => {
+            const pkgSnapshot = pkgSnapshots[depPath];
+            const pkgInfo = nameVerFromPkgSnapshot(depPath, pkgSnapshot);
+            const modules = path.join(ctx.virtualStoreDir, dp.depPathToFilename(depPath, opts.virtualStoreDirMaxLength), 'node_modules');
+            const binPath = path.join(modules, pkgInfo.name, 'node_modules', '.bin');
+            return linkBins(modules, binPath, { warn });
+        })));
+        await Promise.all(Object.values(ctx.projects).map(async ({ rootDir }) => limitLinking(async () => {
+            const modules = path.join(rootDir, 'node_modules');
+            const binPath = path.join(modules, '.bin');
+            return linkBins(modules, binPath, {
+                allowExoticManifests: true,
+                warn,
+            });
+        })));
+    }
+    return { pkgsThatWereRebuilt, ignoredPkgs };
+}
+function binDirsInAllParentDirs(pkgRoot, lockfileDir) {
+    const binDirs = [];
+    let dir = pkgRoot;
+    do {
+        if (!(path.dirname(dir)[0] === '@')) {
+            binDirs.push(path.join(dir, 'node_modules/.bin'));
+        }
+        dir = path.dirname(dir);
+    } while (path.relative(dir, lockfileDir) !== '');
+    binDirs.push(path.join(lockfileDir, 'node_modules/.bin'));
+    return binDirs;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@pnpm/building.after-install",
+  "version": "1000.0.0-0",
+  "description": "Rebuild packages that are already installed by running their lifecycle scripts",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "rebuild"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/building/after-install",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/building/after-install#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/npm-package-arg": "^2.0.0",
+    "load-json-file": "^7.0.1",
+    "p-limit": "^7.1.0",
+    "run-groups": "^4.0.0",
+    "semver": "^7.7.2",
+    "@pnpm/building.pkg-requires-build": "1000.0.0-0",
+    "@pnpm/building.policy": "1000.0.0-0",
+    "@pnpm/calc-dep-state": "1002.0.8",
+    "@pnpm/config": "1004.4.2",
+    "@pnpm/core-loggers": "1001.0.4",
+    "@pnpm/constants": "1001.3.1",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/get-context": "1001.1.8",
+    "@pnpm/lifecycle": "1001.0.25",
+    "@pnpm/link-bins": "1000.2.6",
+    "@pnpm/deps.graph-sequencer": "1000.0.0",
+    "@pnpm/dependency-path": "1001.1.3",
+    "@pnpm/lockfile.types": "1002.0.2",
+    "@pnpm/lockfile.utils": "1003.0.3",
+    "@pnpm/modules-yaml": "1000.3.6",
+    "@pnpm/normalize-registries": "1000.1.4",
+    "@pnpm/store-connection-manager": "1002.2.4",
+    "@pnpm/read-package-json": "1000.1.2",
+    "@pnpm/store.cafs": "1000.0.19",
+    "@pnpm/lockfile.walker": "1001.0.16",
+    "@pnpm/store.index": "1000.0.0-0",
+    "@pnpm/store-controller-types": "1004.1.0",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0",
+    "@pnpm/worker": "^1000.3.0"
+  },
+  "devDependencies": {
+    "@types/semver": "7.7.1",
+    "@pnpm/building.after-install": "1000.0.0-0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\"",
+    "compile": "tsgo --build && pnpm run lint --fix",
+    "test": "pnpm run compile"
+  }
+}