@pnpm/store.controller 1004.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,13 @@
+# @pnpm/package-store
+
+> A storage for packages
+
+## Installation
+
+```
+pnpm add @pnpm/package-store
+```
+
+## License
+
+[MIT](LICENSE)

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export { type CafsLocker, createPackageStore, type CreatePackageStoreOptions } from './storeController/index.js';
+export { getRegisteredProjects, registerProject } from './storeController/projectRegistry.js';
+export * from '@pnpm/store.controller-types';

package/lib/index.js

@@ -0,0 +1,4 @@
+export { createPackageStore } from './storeController/index.js';
+export { getRegisteredProjects, registerProject } from './storeController/projectRegistry.js';
+export * from '@pnpm/store.controller-types';
+//# sourceMappingURL=index.js.map

package/lib/storeController/index.d.ts

@@ -0,0 +1,27 @@
+import type { Fetchers } from '@pnpm/fetching.fetcher-base';
+import type { CustomFetcher } from '@pnpm/hooks.types';
+import type { ResolveFunction } from '@pnpm/resolving.resolver-base';
+import type { ImportIndexedPackageAsync, StoreController } from '@pnpm/store.controller-types';
+import { type CafsLocker } from '@pnpm/store.create-cafs-store';
+import type { StoreIndex } from '@pnpm/store.index';
+export { type CafsLocker };
+export interface CreatePackageStoreOptions {
+    cafsLocker?: CafsLocker;
+    engineStrict?: boolean;
+    force?: boolean;
+    nodeVersion?: string;
+    importPackage?: ImportIndexedPackageAsync;
+    pnpmVersion?: string;
+    ignoreFile?: (filename: string) => boolean;
+    cacheDir: string;
+    storeDir: string;
+    networkConcurrency?: number;
+    packageImportMethod?: 'auto' | 'hardlink' | 'copy' | 'clone' | 'clone-or-copy';
+    verifyStoreIntegrity: boolean;
+    virtualStoreDirMaxLength: number;
+    strictStorePkgContentCheck?: boolean;
+    clearResolutionCache: () => void;
+    customFetchers?: CustomFetcher[];
+    storeIndex: StoreIndex;
+}
+export declare function createPackageStore(resolve: ResolveFunction, fetchers: Fetchers, initOpts: CreatePackageStoreOptions): StoreController;

package/lib/storeController/index.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createPackageRequester } from '@pnpm/installing.package-requester';
+import { createCafsStore, createPackageImporterAsync } from '@pnpm/store.create-cafs-store';
+import { addFilesFromDir, importPackage, initStoreDir } from '@pnpm/worker';
+import { prune } from './prune.js';
+export {};
+export function createPackageStore(resolve, fetchers, initOpts) {
+    const storeDir = initOpts.storeDir;
+    if (!fs.existsSync(path.join(storeDir, 'files'))) {
+        initStoreDir(storeDir).catch();
+    }
+    const cafs = createCafsStore(storeDir, {
+        cafsLocker: initOpts.cafsLocker,
+        packageImportMethod: initOpts.packageImportMethod,
+    });
+    const packageRequester = createPackageRequester({
+        force: initOpts.force,
+        engineStrict: initOpts.engineStrict,
+        nodeVersion: initOpts.nodeVersion,
+        pnpmVersion: initOpts.pnpmVersion,
+        resolve,
+        fetchers,
+        cafs,
+        ignoreFile: initOpts.ignoreFile,
+        networkConcurrency: initOpts.networkConcurrency,
+        storeDir: initOpts.storeDir,
+        verifyStoreIntegrity: initOpts.verifyStoreIntegrity,
+        virtualStoreDirMaxLength: initOpts.virtualStoreDirMaxLength,
+        strictStorePkgContentCheck: initOpts.strictStorePkgContentCheck,
+        customFetchers: initOpts.customFetchers,
+    });
+    return {
+        close: async () => {
+            initOpts.storeIndex.flush();
+        },
+        fetchPackage: packageRequester.fetchPackageToStore,
+        getFilesIndexFilePath: packageRequester.getFilesIndexFilePath,
+        importPackage: initOpts.importPackage
+            ? createPackageImporterAsync({ importIndexedPackage: initOpts.importPackage, storeDir: cafs.storeDir })
+            : (targetDir, opts) => importPackage({
+                ...opts,
+                packageImportMethod: initOpts.packageImportMethod,
+                storeDir: initOpts.storeDir,
+                targetDir,
+            }),
+        prune: prune.bind(null, { storeDir, cacheDir: initOpts.cacheDir, storeIndex: initOpts.storeIndex }),
+        requestPackage: packageRequester.requestPackage,
+        upload,
+        clearResolutionCache: initOpts.clearResolutionCache,
+    };
+    async function upload(builtPkgLocation, opts) {
+        await addFilesFromDir({
+            storeDir: cafs.storeDir,
+            storeIndex: initOpts.storeIndex,
+            dir: builtPkgLocation,
+            sideEffectsCacheKey: opts.sideEffectsCacheKey,
+            filesIndexFile: opts.filesIndexFile,
+            pkg: {},
+        });
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/storeController/projectRegistry.d.ts

@@ -0,0 +1,11 @@
+export declare function getProjectsRegistryDir(storeDir: string): string;
+/**
+ * Register a project as using the store.
+ * Creates a symlink in {storeDir}/projects/{hash} → {projectDir}
+ */
+export declare function registerProject(storeDir: string, projectDir: string): Promise<void>;
+/**
+ * Get all registered projects that use the global virtual store.
+ * Cleans up stale entries (projects that no longer exist).
+ */
+export declare function getRegisteredProjects(storeDir: string): Promise<string[]>;

package/lib/storeController/projectRegistry.js

@@ -0,0 +1,90 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { createShortHash } from '@pnpm/crypto.hash';
+import { PnpmError } from '@pnpm/error';
+import { globalInfo } from '@pnpm/logger';
+import { isSubdir } from 'is-subdir';
+import symlinkDir from 'symlink-dir';
+const PROJECTS_DIR = 'projects';
+export function getProjectsRegistryDir(storeDir) {
+    return path.join(storeDir, PROJECTS_DIR);
+}
+/**
+ * Register a project as using the store.
+ * Creates a symlink in {storeDir}/projects/{hash} → {projectDir}
+ */
+export async function registerProject(storeDir, projectDir) {
+    // Avoid creating circular symlinks when the store is inside the project directory
+    if (isSubdir(projectDir, storeDir)) {
+        return;
+    }
+    const registryDir = getProjectsRegistryDir(storeDir);
+    await fs.mkdir(registryDir, { recursive: true });
+    const linkPath = path.join(registryDir, createShortHash(projectDir));
+    // symlink-dir handles the case where the symlink already exists
+    await symlinkDir(projectDir, linkPath);
+}
+/**
+ * Get all registered projects that use the global virtual store.
+ * Cleans up stale entries (projects that no longer exist).
+ */
+export async function getRegisteredProjects(storeDir) {
+    const registryDir = getProjectsRegistryDir(storeDir);
+    let entries;
+    try {
+        entries = await fs.readdir(registryDir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    const projects = [];
+    await Promise.all(entries.map(async (entry) => {
+        if (entry.name.startsWith('.'))
+            return;
+        // We expect only symlinks (or junctions on Windows) in the registry
+        if (!entry.isSymbolicLink())
+            return;
+        const linkPath = path.join(registryDir, entry.name);
+        // Read the symlink target - if this fails, it's an invalid entry
+        let target;
+        try {
+            target = await fs.readlink(linkPath);
+        }
+        catch (err) {
+            // If the file is not a symlink (EINVAL) or doesn't exist (ENOENT), ignore it
+            if (util.types.isNativeError(err) && 'code' in err && (err.code === 'ENOENT' || err.code === 'EINVAL')) {
+                return;
+            }
+            // For permission errors etc, inform the user
+            const message = util.types.isNativeError(err) ? err.message : String(err);
+            throw new PnpmError('PROJECT_REGISTRY_ENTRY_INACCESSIBLE', `Cannot read project registry entry "${linkPath}": ${message}`, {
+                hint: `To remove this project from the registry, delete the file at:\n  ${linkPath}`,
+            });
+        }
+        const absoluteTarget = path.isAbsolute(target) ? target : path.resolve(path.dirname(linkPath), target);
+        // Check if project still exists
+        try {
+            await fs.stat(absoluteTarget);
+            projects.push(absoluteTarget);
+        }
+        catch (err) {
+            // Only clean up if project directory no longer exists
+            if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+                await fs.unlink(linkPath);
+                globalInfo(`Removed stale project registry entry: ${absoluteTarget}`);
+                return;
+            }
+            // Can't access project - throw error to prevent incorrect pruning
+            const message = util.types.isNativeError(err) ? err.message : String(err);
+            throw new PnpmError('PROJECT_INACCESSIBLE', `Cannot access registered project "${absoluteTarget}": ${message}`, {
+                hint: `To remove this project from the registry, delete the symlink at:\n  ${linkPath}`,
+            });
+        }
+    }));
+    return projects;
+}
+//# sourceMappingURL=projectRegistry.js.map

package/lib/storeController/prune.d.ts

@@ -0,0 +1,7 @@
+import type { StoreIndex } from '@pnpm/store.index';
+export interface PruneOptions {
+    cacheDir: string;
+    storeDir: string;
+    storeIndex: StoreIndex;
+}
+export declare function prune({ cacheDir, storeDir, storeIndex }: PruneOptions, removeAlienFiles?: boolean): Promise<void>;

package/lib/storeController/prune.js

@@ -0,0 +1,91 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { globalInfo, globalWarn } from '@pnpm/logger';
+import { rimraf } from '@zkochan/rimraf';
+import { pruneGlobalVirtualStore } from './pruneGlobalVirtualStore.js';
+const BIG_ONE = BigInt(1);
+export async function prune({ cacheDir, storeDir, storeIndex }, removeAlienFiles) {
+    // 1. First, prune the global virtual store
+    // This must happen BEFORE pruning the CAS, because removing packages from
+    // the virtual store will reduce hard link counts on files in the CAS
+    await pruneGlobalVirtualStore(storeDir);
+    // 2. Clean up metadata cache
+    const metadataDirs = await getSubdirsSafely(cacheDir);
+    await Promise.all(metadataDirs.map(async (metadataDir) => {
+        if (!metadataDir.startsWith('metadata'))
+            return;
+        try {
+            await rimraf(path.join(cacheDir, metadataDir));
+        }
+        catch (err) {
+            if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
+                throw err;
+            }
+        }
+    }));
+    await rimraf(path.join(storeDir, 'tmp'));
+    globalInfo('Removed all cached metadata files');
+    // 3. Prune the content-addressable store (CAS)
+    const cafsDir = path.join(storeDir, 'files');
+    const removedHashes = new Set();
+    const dirs = await getSubdirsSafely(cafsDir);
+    let fileCounter = 0;
+    await Promise.all(dirs.map(async (dir) => {
+        const subdir = path.join(cafsDir, dir);
+        await Promise.all((await fs.readdir(subdir)).map(async (fileName) => {
+            const filePath = path.join(subdir, fileName);
+            const stat = await fs.stat(filePath);
+            if (stat.isDirectory()) {
+                if (removeAlienFiles) {
+                    await rimraf(filePath);
+                    globalWarn(`An alien directory has been removed from the store: ${filePath}`);
+                    fileCounter++;
+                    return;
+                }
+                else {
+                    globalWarn(`An alien directory is present in the store: ${filePath}`);
+                    return;
+                }
+            }
+            if (stat.nlink === 1 || stat.nlink === BIG_ONE) {
+                await fs.unlink(filePath);
+                fileCounter++;
+                // Store the hex digest, which matches the format stored in PackageFileInfo.digest
+                // The file name in the store is the hex representation of the hash (with optional -exec suffix)
+                removedHashes.add(`${dir}${fileName.replace(/-exec$/, '')}`);
+            }
+        }));
+    }));
+    globalInfo(`Removed ${fileCounter} file${fileCounter === 1 ? '' : 's'}`);
+    // 4. Clean up orphaned package index entries
+    let pkgCounter = 0;
+    const toDelete = [];
+    for (const [filesIndexFile, data] of storeIndex.entries()) {
+        const pkgFilesIndex = data;
+        const pkgJson = pkgFilesIndex.files.get('package.json');
+        // TODO: implement prune of Node.js packages, they don't have a package.json file
+        if (pkgJson && removedHashes.has(pkgJson.digest)) {
+            toDelete.push(filesIndexFile);
+            pkgCounter++;
+        }
+    }
+    storeIndex.deleteMany(toDelete);
+    globalInfo(`Removed ${pkgCounter} package${pkgCounter === 1 ? '' : 's'}`);
+}
+async function getSubdirsSafely(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    return entries
+        .filter(entry => entry.isDirectory())
+        .map(dir => dir.name);
+}
+//# sourceMappingURL=prune.js.map

package/lib/storeController/pruneGlobalVirtualStore.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Prune unused packages from the global virtual store using mark-and-sweep:
+ * 1. Get all registered projects
+ * 2. Find all node_modules directories in each project (including workspace packages)
+ * 3. Walk symlinks from each node_modules to mark reachable packages
+ * 4. Remove any package directories that weren't marked as reachable
+ */
+export declare function pruneGlobalVirtualStore(storeDir: string): Promise<void>;

package/lib/storeController/pruneGlobalVirtualStore.js

@@ -0,0 +1,245 @@
+import crypto from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { globalInfo } from '@pnpm/logger';
+import { rimraf } from '@zkochan/rimraf';
+import { isSubdir } from 'is-subdir';
+import { getRegisteredProjects } from './projectRegistry.js';
+const LINKS_DIR = 'links';
+/**
+ * Prune unused packages from the global virtual store using mark-and-sweep:
+ * 1. Get all registered projects
+ * 2. Find all node_modules directories in each project (including workspace packages)
+ * 3. Walk symlinks from each node_modules to mark reachable packages
+ * 4. Remove any package directories that weren't marked as reachable
+ */
+export async function pruneGlobalVirtualStore(storeDir) {
+    const linksDir = path.join(storeDir, LINKS_DIR);
+    if (!await pathExists(linksDir)) {
+        return;
+    }
+    const projects = await getRegisteredProjects(storeDir);
+    if (projects.length === 0) {
+        globalInfo('No registered projects for global virtual store');
+        return;
+    }
+    globalInfo(`Checking ${projects.length} registered project(s) for global virtual store usage`);
+    // Mark phase: collect all reachable package directories
+    const reachable = new Set();
+    const visited = new Set(); // Track visited directories to prevent infinite loops
+    // For each project, find all node_modules directories (root + workspace packages)
+    await Promise.all(projects.map(async (projectDir) => {
+        const nodeModulesDirs = await findAllNodeModulesDirs(projectDir);
+        await Promise.all(nodeModulesDirs.map((modulesDir) => walkSymlinksToStore(modulesDir, linksDir, reachable, visited)));
+    }));
+    // Sweep phase: remove unreachable packages
+    const unreachableCount = await removeUnreachablePackages(linksDir, reachable);
+    if (unreachableCount > 0) {
+        globalInfo(`Removed ${unreachableCount} package${unreachableCount === 1 ? '' : 's'} from global virtual store`);
+    }
+    else {
+        globalInfo('No unused packages found in global virtual store');
+    }
+}
+/**
+ * Find all node_modules directories within a project, including those
+ * in workspace packages. Does not descend into node_modules directories.
+ */
+async function findAllNodeModulesDirs(projectDir) {
+    const nodeModulesDirs = [];
+    async function scan(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        const subdirs = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const entryPath = path.join(dir, entry.name);
+            if (entry.name === 'node_modules') {
+                nodeModulesDirs.push(entryPath);
+                // Don't descend into node_modules
+            }
+            else if (!entry.name.startsWith('.')) {
+                // Collect directories to descend into (workspace packages, etc.)
+                // Skip hidden directories like .git, .pnpm
+                subdirs.push(entryPath);
+            }
+        }
+        // Scan subdirectories concurrently
+        await Promise.all(subdirs.map((subdir) => scan(subdir)));
+    }
+    await scan(projectDir);
+    return nodeModulesDirs;
+}
+/**
+ * Recursively walk symlinks from a directory, marking any that point
+ * into the global virtual store's links directory.
+ */
+async function walkSymlinksToStore(dir, linksDir, reachable, visited) {
+    // Prevent infinite loops from circular symlinks
+    const dirHash = await getRealPathHash(dir);
+    if (visited.has(dirHash)) {
+        return;
+    }
+    visited.add(dirHash);
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isSymbolicLink()) {
+            try {
+                const target = await fs.readlink(entryPath);
+                const absoluteTarget = path.isAbsolute(target)
+                    ? target
+                    : path.resolve(dir, target);
+                // Check if this symlink points into the global virtual store
+                if (isSubdir(linksDir, absoluteTarget)) {
+                    // Mark the package directory as reachable
+                    // The path structure is:
+                    //   - Scoped:   {linksDir}/{scope}/{pkgName}/{version}/{hash}/node_modules/{pkgName}
+                    //   - Unscoped: {linksDir}/@/{pkgName}/{version}/{hash}/node_modules/{pkgName}
+                    // We want to mark the {hash} directory
+                    const relPath = path.relative(linksDir, absoluteTarget);
+                    const parts = relPath.split(path.sep);
+                    // Find the hash directory (the one containing node_modules)
+                    const nodeModulesIdx = parts.indexOf('node_modules');
+                    if (nodeModulesIdx !== -1) {
+                        // Store relative path like "@scope/pkg-a/1.0.0/hash123" or "@/pkg-a/1.0.0/hash123"
+                        const relativePath = parts.slice(0, nodeModulesIdx).join(path.sep);
+                        reachable.add(relativePath);
+                        // Also walk into the package's node_modules for transitive deps
+                        const pkgNodeModules = path.join(linksDir, relativePath, 'node_modules');
+                        await walkSymlinksToStore(pkgNodeModules, linksDir, reachable, visited);
+                    }
+                }
+            }
+            catch {
+                // Ignore broken symlinks
+            }
+        }
+        else if (entry.isDirectory() && entry.name !== '.pnpm') {
+            // Recurse into directories (but not .pnpm which is the local virtual store)
+            await walkSymlinksToStore(entryPath, linksDir, reachable, visited);
+        }
+    }));
+}
+/**
+ * Resolve symlinks and return a hash of the real path (for cycle detection)
+ */
+async function getRealPathHash(p) {
+    let realPath;
+    try {
+        realPath = await fs.realpath(p);
+    }
+    catch {
+        realPath = p;
+    }
+    // Create a compact hash for in-memory use (base64url is shorter than hex that we use for file name hashes)
+    return crypto.createHash('sha256').update(realPath).digest('base64url');
+}
+/**
+ * Remove package directories from the global virtual store that are not in the reachable set.
+ * Returns the count of removed packages.
+ *
+ * Directory structure is uniform 4-level:
+ * - Scoped: {linksDir}/{scope}/{pkgName}/{version}/{hash}/
+ * - Unscoped: {linksDir}/@/{pkgName}/{version}/{hash}/
+ */
+async function removeUnreachablePackages(linksDir, reachable) {
+    // First level is always a scope (either @scope or @ for unscoped packages)
+    const scopes = await getSubdirsSafely(linksDir);
+    let count = 0;
+    await Promise.all(scopes.map(async (scope) => {
+        const scopePath = path.join(linksDir, scope);
+        const pkgNames = await getSubdirsSafely(scopePath);
+        let removedPkgs = 0;
+        await Promise.all(pkgNames.map(async (pkgName) => {
+            const pkgDir = path.join(scopePath, pkgName);
+            const removedVersions = await removeUnreachableVersions(pkgDir, path.join(scope, pkgName), reachable);
+            count += removedVersions.count;
+            if (removedVersions.allRemoved) {
+                // Remove the package directory when all its versions are removed
+                await rimraf(pkgDir);
+                removedPkgs++;
+            }
+        }));
+        // If we removed all packages in scope, remove the scope directory
+        if (removedPkgs === pkgNames.length && pkgNames.length > 0) {
+            await rimraf(scopePath);
+        }
+    }));
+    return count;
+}
+/**
+ * Remove unreachable versions and hashes for a package.
+ * Returns the count of removed packages and whether all versions were removed.
+ */
+async function removeUnreachableVersions(pkgDir, pkgPath, // relative path like "@/is-positive" or "@pnpm.e2e/romeo"
+reachable) {
+    const versions = await getSubdirsSafely(pkgDir);
+    let count = 0;
+    let removedVersions = 0;
+    await Promise.all(versions.map(async (version) => {
+        const versionDir = path.join(pkgDir, version);
+        const hashes = await getSubdirsSafely(versionDir);
+        // Remove unreachable hash directories
+        let removedHashes = 0;
+        await Promise.all(hashes.map(async (hash) => {
+            const relativePath = path.join(pkgPath, version, hash);
+            if (!reachable.has(relativePath)) {
+                await rimraf(path.join(versionDir, hash));
+                removedHashes++;
+                count++;
+            }
+        }));
+        // If we removed all hashes, remove the version directory
+        if (removedHashes === hashes.length && hashes.length > 0) {
+            await rimraf(versionDir);
+            removedVersions++;
+        }
+    }));
+    return {
+        count,
+        allRemoved: removedVersions === versions.length && versions.length > 0,
+    };
+}
+async function pathExists(p) {
+    try {
+        await fs.stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getSubdirsSafely(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            subdirs.push(entry.name);
+        }
+    }
+    return subdirs;
+}
+//# sourceMappingURL=pruneGlobalVirtualStore.js.map

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@pnpm/store.controller",
+  "version": "1004.0.0",
+  "description": "A storage for packages",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "cache",
+    "central storage",
+    "global store",
+    "maching store",
+    "packages",
+    "storage",
+    "store"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/store/controller",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/store/controller#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"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@zkochan/rimraf": "^4.0.0",
+    "is-subdir": "^2.0.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "ssri": "13.0.0",
+    "symlink-dir": "^7.0.0",
+    "@pnpm/fetching.fetcher-base": "1001.0.2",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/installing.package-requester": "1008.0.0",
+    "@pnpm/hooks.types": "1001.0.12",
+    "@pnpm/resolving.resolver-base": "1005.1.0",
+    "@pnpm/store.cafs": "1000.0.19",
+    "@pnpm/store.controller-types": "1004.1.0",
+    "@pnpm/store.create-cafs-store": "1000.0.20",
+    "@pnpm/store.index": "1000.0.0-0",
+    "@pnpm/crypto.hash": "1000.2.1",
+    "@pnpm/types": "1000.9.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0",
+    "@pnpm/worker": "^1000.3.0"
+  },
+  "devDependencies": {
+    "@types/ramda": "0.29.12",
+    "@types/ssri": "^7.1.5",
+    "tempy": "3.0.0",
+    "@pnpm/installing.client": "1001.1.4",
+    "@pnpm/logger": "1001.0.1",
+    "@pnpm/store.controller": "1004.0.0",
+    "@pnpm/prepare": "1000.0.4"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "start": "tsgo --watch",
+    "fix": "tslint -c tslint.json src/**/*.ts test/**/*.ts --fix",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "pretest": "rimraf .tmp",
+    "_test": "pnpm pretest && cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}