package-management 0.0.16 → 0.1.0

package/dist/index.mjs

@@ -1,25 +1,88 @@
-import ErrorStackParser from 'error-stack-parser';
-import path$1, { normalize, basename, dirname, relative, join } from 'pathe';
-import process from 'node:process';
-import path from 'node:path';
+import path, { isAbsolute, dirname, normalize, join } from 'pathe';
+import util from 'node:util';
 import { fileURLToPath } from 'node:url';
-import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, accessSync, constants, statSync, readFileSync } from 'node:fs';
 import { asyncCacheFn } from 'async-cache-fn';
 import { execaSync, execa } from 'execa';
 import { findUp } from 'find-up';
 import { readFile, rm } from 'node:fs/promises';
 import { resolvePathSync } from 'mlly';
+import * as WST from 'workspace-tools';
+import process from 'node:process';
+import path$1 from 'node:path';
 import { globbySync } from 'globby';
 import gitignoreParser from 'parse-gitignore';
-import * as WST from 'workspace-tools';
 import { resolveAlias } from 'pathe/utils';
 import os from 'node:os';
-import { modify, applyEdits } from 'jsonc-parser';
-import { morph } from '@arktype/util';
+import { parse, applyEdits, modify } from 'jsonc-parser';
 import { createStorage, restoreSnapshot, snapshot } from 'unstorage';
 import defineMemoryDriver from 'unstorage/drivers/memory';
 import defineFsLiteDriver from 'unstorage/drivers/fs-lite';
 
+const getCallSites = "getCallSites" in util ? util.getCallSites : void 0;
+const MAX_FRAMES = 200;
+function resolveCallerFile(options) {
+  const { from, boundaryFunctionName, internalScripts = [] } = options ?? {};
+  if (from) return toCallerPath(String(from));
+  if (getCallSites === void 0) return void 0;
+  const sites = getCallSites(MAX_FRAMES, { sourceMap: true });
+  const scriptName = boundaryFunctionName && frameAfterFunction(sites, boundaryFunctionName) || firstForeignFrame(sites, [OWN_SCRIPT, ...internalScripts]);
+  return scriptName ? toFilePath(scriptName) : void 0;
+}
+const OWN_SCRIPT = import.meta.url;
+function frameAfterFunction(sites, functionName) {
+  const boundary = sites.findIndex((site) => site.functionName === functionName);
+  return boundary === -1 ? void 0 : sites[boundary + 1]?.scriptName;
+}
+function firstForeignFrame(sites, internalScripts) {
+  const internal = new Set(internalScripts.map(toFilePath));
+  return sites.find(
+    (site) => (
+      // Frames from `node:` internals and evaluated code name no file, so they
+      // are never the caller's location however far out they appear.
+      isFileScript(site.scriptName) && !internal.has(toFilePath(site.scriptName))
+    )
+  )?.scriptName;
+}
+const isFileScript = (script) => Boolean(script) && (script.startsWith("file:") || isAbsolute(script));
+const toFilePath = (script) => script.startsWith("file:") ? fileURLToPath(script) : script;
+function toCallerPath(from) {
+  if (from.startsWith("file:")) return fileURLToPath(from);
+  if (isAbsolute(from)) return from;
+  throw new Error(
+    `\`from\` must be a file: URL or an absolute path, received ${JSON.stringify(from)}. Pass \`import.meta.url\`.`
+  );
+}
+
+const _filename = (options) => resolveCallerFile(withOwnScript(options));
+const _dirname = (options) => {
+  const filePath = resolveCallerFile(withOwnScript(options));
+  return filePath === void 0 ? void 0 : dirname(filePath);
+};
+const withOwnScript = (options) => ({
+  ...options,
+  internalScripts: [...options?.internalScripts ?? [], import.meta.url]
+});
+
+function createFile(filePath, data, options) {
+  const { encoding = "utf-8", ...rest } = typeof options === "string" ? { encoding: options } : options ?? {};
+  const dir = path.dirname(filePath);
+  const writeFileOptions = { encoding, ...rest };
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, data, writeFileOptions);
+}
+
+function isWritable(filename) {
+  try {
+    accessSync(filename, constants.W_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
 const toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
 const fromEntries = (entries) => Object.fromEntries(entries);
@@ -33,7 +96,7 @@ const select = (obj, selection, mode) => {
 };
 function normalizePath(path, option) {
   if (typeof option === "function") {
-    return normalizePath(path);
+    return option(path);
   }
   if (option === false) {
     return path;
@@ -45,14 +108,6 @@ const invariant = (predicate, message) => {
     throw new Error(message);
   }
 };
-function getArrayItemAtOffset(arr, index, offset = 0) {
-  if (arr === void 0 || index === void 0) return void 0;
-  return arr[index + offset];
-}
-function isMatching(a, b) {
-  if (!a || !b) return false;
-  return a === b;
-}
 function checkResult(cb, options) {
   try {
     return buildSingleProp({
@@ -77,123 +132,16 @@ function buildSingleProp(entry) {
   return { [key]: value };
 }
 
-function findCallerStackFrame(options) {
-  return findErrorStackFrame(options, (frame) => frame.isParentOfRootFunction);
-}
-function findErrorStackFrame(options, find) {
-  return getErrorStackFrames(options, find)[0];
-}
-function getErrorStackFrames(options, filter) {
-  const { error, rootFunctionName, startFrom = "top" } = options;
-  const frames = startFrom === "bottom" ? ErrorStackParser.parse(error).reverse() : ErrorStackParser.parse(error);
-  const { parsedFrames } = frames.reduce(
-    (acc, frame, index) => {
-      const parsed = parseFrame({
-        frame,
-        index,
-        rootFunctionName,
-        frames
-      });
-      const isValid = filter ? filter(parsed) : true;
-      if (isValid) {
-        acc.parsedFrames.push(parsed);
-      }
-      return acc;
-    },
-    { parsedFrames: [] }
-  );
-  return parsedFrames ?? [];
-}
-function parseFrame(options) {
-  const { frame, frames, index, rootFunctionName, cwd, debug } = options ?? {};
-  const functionName = parseFunctionName(frame.functionName);
-  const isRootFunction = isMatching(functionName, rootFunctionName);
-  const beforeFrameFunctionName = parseFunctionName(
-    getArrayItemAtOffset(frames, index, -1)?.functionName
-  );
-  const isParentOfRootFunction = isMatching(
-    beforeFrameFunctionName,
-    rootFunctionName
-  );
-  const fileData = frame.fileName ? getFilePathData({ filepath: frame.fileName, cwd }) : void 0;
-  const { isFileInCwd: isFrameInScope, ...restFileData } = fileData ?? {};
-  const data = {
-    ...restFileData,
-    functionName,
-    source: frame.source,
-    sourceFunctionName: frame.functionName,
-    isFrameInScope,
-    place: placeFormatter(index, frames?.length),
-    isRootFunction,
-    isParentOfRootFunction,
-    rootFunctionName
-  };
-  debug && console.log(data);
-  return data;
-}
-function getFilePathData({
-  filepath,
-  cwd
-}) {
-  const workingDir = cwd ?? process.cwd();
-  const filePath = normalize(toFilePath(filepath));
-  const fileBasename = basename(filePath);
-  const dirPath = dirname(filePath);
-  const dirBasename = basename(dirPath);
-  const relativeFilePath = relative(workingDir, filePath);
-  const relativeDirPath = dirname(relativeFilePath);
-  const isFileInCwd = filePath.startsWith(workingDir);
-  return {
-    filePath,
-    dirPath,
-    relativeFilePath,
-    relativeDirPath,
-    fileBasename,
-    dirBasename,
-    isFileInCwd
-  };
-}
-function toFilePath(fileName) {
-  return fileName.startsWith("file:") ? fileURLToPath(fileName) : fileName;
-}
-function parseFunctionName(functionName) {
-  if (!functionName) return void 0;
-  return removeStart(functionName, "Module.");
-}
-function removeStart(input, value) {
-  return input.startsWith(value) ? input.slice(value.length) : input;
-}
-function placeFormatter(index, total) {
-  if (index === void 0 || !total) return void 0;
-  return [index, total].join("/");
-}
-
-const _filename = (options) => {
-  const { filePath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
-  return filePath;
-};
-const _dirname = (options) => {
-  const { dirPath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
-  return dirPath;
-};
-
 async function resolveModule(module) {
   const resolved = await module;
-  return resolved.default || resolved;
+  const hasDefault = resolved !== null && typeof resolved === "object" && "default" in resolved;
+  return hasDefault ? resolved.default : resolved;
 }
 function isPackageModuleFound(name, options) {
   return Boolean(resolvePackageModulePath(name, options));
 }
 function resolvePackageModulePath(name, options) {
-  const resolvedPath = findResolvedModulePath(
-    [`${name}/package.json`, name],
-    options
-  );
-  if (resolvedPath === void 0) {
-    console.error(`Could not resolve package ${name}`);
-    return void 0;
-  }
-  return resolvedPath;
+  return findResolvedModulePath([`${name}/package.json`, name], options);
 }
 function findResolvedModulePath(paths, options) {
   for (const path of paths) {
@@ -215,28 +163,68 @@ function resolveModulePath(modulePath, options) {
   }
 }
 
+function getPackageFolder(options) {
+  return WST.findPackageRoot(options?.cwd ?? process.cwd());
+}
+
+function getPackageInfo(options) {
+  const packageDir = getPackageFolder(options);
+  if (!packageDir) {
+    throw new Error(
+      `No package.json found searching up from "${options?.cwd ?? process.cwd()}"`
+    );
+  }
+  return readPackageInfo({ packageDir });
+}
+function readPackageInfo({
+  packageDir
+}) {
+  const packageJsonPath = path$1.join(packageDir, "package.json");
+  const packageJson = readPackageJson(packageJsonPath);
+  return {
+    name: packageJson.name,
+    path: packageJsonPath,
+    dirpath: packageDir,
+    packageJson
+  };
+}
+const packageJsonCache = /* @__PURE__ */ new Map();
+function readPackageJson(packageJsonPath) {
+  const { mtimeMs } = statSync(packageJsonPath);
+  const cached = packageJsonCache.get(packageJsonPath);
+  if (cached?.mtimeMs === mtimeMs) return cached.packageJson;
+  const packageJson = JSON.parse(
+    readFileSync(packageJsonPath, "utf-8")
+  );
+  packageJsonCache.set(packageJsonPath, { mtimeMs, packageJson });
+  return packageJson;
+}
+
 const tsconfig = (tsconfigDir) => ({
   get paths() {
+    if (!tsconfigDir) return [];
     return globbySync(["tsconfig.json", "tsconfig.*.json"], {
-      cwd: tsconfigDir
-    }) ?? [];
+      cwd: tsconfigDir,
+      absolute: true
+    });
   }
 });
 
-function parseGitignoreFile(gitignorePath, options) {
-  return gitignoreParser(gitignorePath, options);
+function parseGitignoreContent(gitignoreContent, options) {
+  return gitignoreParser(gitignoreContent, options);
 }
-function getGitignoreData(gitignorePath) {
-  const gitignoreFileContent = readFileSync(gitignorePath, "utf-8");
-  const gitignores = parseGitignoreFile(gitignoreFileContent);
-  return gitignores;
+function getGitignoreData(gitignorePath, options) {
+  if (!gitignorePath || !existsSync(gitignorePath)) {
+    return parseGitignoreContent("", options);
+  }
+  return parseGitignoreContent(readFileSync(gitignorePath, "utf-8"), options);
 }
-const gitignore = (gitignorePath) => ({
+const gitignore = (gitignorePath, options) => ({
   get data() {
-    return getGitignoreData(gitignorePath);
+    return getGitignoreData(gitignorePath, options);
   },
   get patterns() {
-    return getGitignoreData(gitignorePath).patterns;
+    return getGitignoreData(gitignorePath, options).patterns;
   }
 });
 
@@ -299,36 +287,13 @@ function getWorkspaceFolder(options) {
     throwIfNotFound = true
   } = options ?? {};
   const getFolder = fallbackToGitRoot ? WST.findProjectRoot : WST.getWorkspaceManagerRoot;
-  const folder = getFolder(cwd);
+  const folder = checkResult(() => getFolder(cwd)).data;
   if (folder === void 0 && throwIfNotFound) {
     throw new Error(`Could not find workspace folder`);
   }
   return folder;
 }
 
-function getPackageFolder(options) {
-  return WST.findPackageRoot(options?.cwd ?? process.cwd());
-}
-
-function getPackageInfo(options) {
-  const packageDir = getPackageFolder(options);
-  return readPackageInfo({ packageDir });
-}
-function readPackageInfo({
-  packageDir
-}) {
-  const packageJsonPath = path.join(packageDir, "package.json");
-  const packageJson = JSON.parse(
-    readFileSync(packageJsonPath, "utf-8")
-  );
-  return {
-    name: packageJson.name,
-    path: packageJsonPath,
-    dirpath: packageDir,
-    packageJson
-  };
-}
-
 function getWorkspaceProjectInfo(options) {
   try {
     const workspaceDir = getWorkspaceFolder(options);
@@ -344,13 +309,21 @@ function getWorkspacePackageInfoList(options) {
   const wstList = WST.getWorkspaceInfos(workspaceDir);
   return resolveWstList(wstList);
 }
+function toPackageInfo(info) {
+  return {
+    name: info.name,
+    dirpath: info.path,
+    path: join(info.path, "package.json"),
+    packageJson: info.packageJson
+  };
+}
 function common(options) {
   const { cwd, includeRoot: includeWorkspace } = options ?? {};
   const workspaceDir = getWorkspaceFolder({ cwd });
   function resolveWstList(list) {
     if (!workspaceDir || !list) return [];
-    if (includeWorkspace) return [getWorkspaceProjectInfo(), ...list];
-    return list;
+    const packages = list.map(toPackageInfo);
+    return includeWorkspace ? [getWorkspaceProjectInfo({ cwd }), ...packages] : packages;
   }
   return {
     workspaceDir,
@@ -367,7 +340,7 @@ function getWorkspacePackageInfoMap(options) {
 
 function getProjectInfoByName(name, options) {
   const { cwd } = options ?? {};
-  return getWorkspacePackageInfoMap({ cwd })[name];
+  return getWorkspacePackageInfoMap({ cwd, includeRoot: true })[name];
 }
 
 function getGitRootFolder(options) {
@@ -382,7 +355,7 @@ function getGitRootFolder(options) {
     }
     return void 0;
   }
-  return path$1.normalize(stdout);
+  return path.normalize(stdout);
 }
 
 function getProjectInfo(folder, options) {
@@ -413,9 +386,14 @@ function parseWorkspaceFolderTypeOptions(option, defaultOptions) {
 
 const project = (...args) => {
   const [source, projectOptions] = args;
-  const { packageJson, packageJsonPath, packageName, projectDir } = info();
   const {
-    findPackageManager: findPackageManager2,
+    packageJson,
+    name: packageName,
+    dirpath: projectDir,
+    path: packageJsonPath
+  } = getProjectInfo(source, projectOptions) ?? {};
+  const {
+    findPackageManager,
     detectPackageManagers,
     detectLockfilePackageManagers,
     detectGlobalPackageManagers,
@@ -423,41 +401,29 @@ const project = (...args) => {
     filterPackageManagers,
     mapPackageManagers
   } = definePackageManagerClient({ cwd: projectDir });
+  const getPackageJson = () => projectDir ? readPackageInfo({ packageDir: projectDir }).packageJson : packageJson;
   return {
     packageJson,
     packageJsonPath,
     packageName,
     projectDir,
-    findPackageManager: findPackageManager2,
+    findPackageManager,
     detectPackageManagers,
     detectGlobalPackageManagers,
     detectLockfilePackageManagers,
     globalVersions,
     mapPackageManagers,
-    tsconfig: tsconfig(projectDir ?? ""),
-    gitignore: gitignore(path$1.join(projectDir ?? "", ".gitignore")),
+    // Passed through as-is: substituting "" for an unresolved project made
+    // both of these read from the calling process's directory instead.
+    tsconfig: tsconfig(projectDir),
+    gitignore: gitignore(
+      projectDir ? path.join(projectDir, ".gitignore") : void 0
+    ),
     filterPackageManagers,
-    getPackageJson: () => get("packageJson"),
-    findDependencyInPackageJson: (options) => findDependencyInPackageJson(options, get("packageJson")),
-    isDependencyInPackageJson: (options) => isDependencyInPackageJson(options, get("packageJson"))
+    getPackageJson,
+    findDependencyInPackageJson: (options) => findDependencyInPackageJson(options, getPackageJson()),
+    isDependencyInPackageJson: (options) => isDependencyInPackageJson(options, getPackageJson())
   };
-  function info() {
-    const {
-      packageJson: packageJson2,
-      name: packageName2,
-      dirpath: projectDir2,
-      path: packageJsonPath2
-    } = getProjectInfo(source, projectOptions) ?? {};
-    return {
-      packageJson: packageJson2,
-      packageJsonPath: packageJsonPath2,
-      packageName: packageName2,
-      projectDir: projectDir2
-    };
-  }
-  function get(key) {
-    return info()[key];
-  }
 };
 
 function getWorkspacePackageNames(options) {
@@ -472,18 +438,24 @@ const workspace = {
   getProject: project
 };
 
-function importer(imports, options) {
+async function importer(imports, options) {
   const { install: defaultInstall = true, installer } = options ?? {};
+  const resolved = imports.map((option) => resolveImportOption(option));
+  const missing = resolved.filter(
+    (option) => Boolean(option.name) && (option.install ?? defaultInstall) && !((option.checkExists ?? true) && isSatisfied(option.name))
+  );
+  await installMissing(
+    missing.filter(({ dev }) => !dev).map(({ name }) => name),
+    { dev: false },
+    installer
+  );
+  await installMissing(
+    missing.filter(({ dev }) => dev).map(({ name }) => name),
+    { dev: true },
+    installer
+  );
   return Promise.all(
-    imports.map(async (e) => {
-      const importOpt = resolveImportOption(e);
-      const shouldInstall = importOpt.install ?? defaultInstall;
-      if (shouldInstall && importOpt.name) {
-        await installImport(importOpt.name, importOpt, installer);
-      }
-      const m = await importOpt.import();
-      return resolveModule(m);
-    })
+    resolved.map(async (option) => resolveModule(await option.import()))
   );
 }
 const definePackage = (option) => {
@@ -507,12 +479,11 @@ function resolveImportOption(option) {
   }
   return option;
 }
-async function installImport(packageName, options, installer) {
-  if (!packageName) return;
-  const { checkExists } = options ?? {};
-  if (checkExists && isPackageDependency(packageName)) return;
+const isSatisfied = (packageName) => isPackageDependency(packageName) && isPackageModuleFound(packageName);
+async function installMissing(packageNames, options, installer) {
+  if (packageNames.length === 0) return;
   const installerFn = installer ?? (await workspace.getProject("<package_folder>").findPackageManager()).installPackage;
-  await installerFn(packageName, options);
+  await installerFn(packageNames, options);
 }
 
 const importMap = async (importMap2, options) => {
@@ -534,20 +505,36 @@ function definePackageManager(config, options) {
     const lockfiles = toArray(config.meta.lockfile);
     return await findUp(lockfiles, { cwd });
   });
+  const globalVersion = asyncCacheFn(
+    async (options2) => {
+      try {
+        const { stdout } = await $$({
+          command,
+          args: [agentOptions.version],
+          cwd: defaultCwd,
+          ...options2
+        });
+        return `${stdout}`.trim();
+      } catch {
+        return void 0;
+      }
+    }
+  );
   const installPackage = async (packageName, options2) => {
     const install = agentArgs.install;
-    const { dev, preferOffline } = select(
-      install.options,
-      {
-        preferOffline: true,
-        cwd: defaultCwd,
-        ...options2
-      });
+    const { dev = false, preferOffline = true } = options2 ?? {};
+    const flags = select(install.options, { dev, preferOffline });
     const packageNames = toArray(packageName);
+    assertInstallableNames(packageNames);
     try {
       await $$({
         command,
-        args: [install.command, dev, preferOffline, ...packageNames],
+        args: [
+          install.command,
+          flags.dev,
+          flags.preferOffline,
+          ...packageNames
+        ],
         cwd: defaultCwd,
         ...options2
       });
@@ -591,19 +578,12 @@ function definePackageManager(config, options) {
       if (!lockfilePath) return void 0;
       return readFile(lockfilePath, "utf8");
     }),
-    globalVersion: asyncCacheFn(async (...args) => {
-      const [options2] = args;
-      try {
-        const { stdout } = await $$({
-          command,
-          args: [agentOptions.version],
-          cwd: defaultCwd,
-          ...options2
-        });
-        return `${stdout}`;
-      } catch (e) {
-        return void 0;
-      }
+    globalVersion,
+    matchesVersion: asyncCacheFn(async (...args) => {
+      const { matchesVersion } = config.meta;
+      if (!matchesVersion) return true;
+      const version = await globalVersion.noCache(...args);
+      return version ? matchesVersion(version) : false;
     }),
     definePackage,
     installPackage,
@@ -617,6 +597,16 @@ function definePackageManager(config, options) {
     }
   };
 }
+function assertInstallableNames(packageNames) {
+  const rejected = packageNames.filter(
+    (name) => name.length === 0 || name.startsWith("-")
+  );
+  if (rejected.length > 0) {
+    throw new Error(
+      `Not a package name: ${rejected.map((name) => JSON.stringify(name)).join(", ")}. A package name cannot be empty or begin with "-".`
+    );
+  }
+}
 async function $$(options) {
   const { command, args = [], silent = true, cwd, shellOptions } = options;
   return execa(command, args.filter(notFalsy), {
@@ -639,7 +629,9 @@ const bun = definePackageManagerConfig({
   command: "bun",
   runner: "bunx",
   meta: {
-    lockfile: "bun.lockb"
+    // Bun wrote a binary lockfile originally and a text one from 1.2 onwards,
+    // so a project using either must still be detected.
+    lockfile: ["bun.lock", "bun.lockb"]
   },
   args: {
     install: {
@@ -650,7 +642,7 @@ const bun = definePackageManagerConfig({
       }
     },
     uninstall: {
-      command: "uninstall"
+      command: "remove"
     }
   },
   options: {
@@ -714,7 +706,9 @@ const yarn = definePackageManagerConfig({
   command: "yarn",
   runner: "yarn dlx",
   meta: {
-    lockfile: "yarn.lock"
+    lockfile: "yarn.lock",
+    // Berry shares this command and lockfile, so the version decides.
+    matchesVersion: (version) => version.startsWith("1.")
   },
   args: {
     install: {
@@ -733,6 +727,33 @@ const yarn = definePackageManagerConfig({
   }
 });
 
+const yarnBerry = definePackageManagerConfig({
+  id: "yarn-berry",
+  name: "Yarn Berry",
+  command: "yarn",
+  runner: "yarn dlx",
+  meta: {
+    lockfile: "yarn.lock",
+    // Classic shares this command and lockfile; everything past 1.x is Berry.
+    matchesVersion: (version) => !version.startsWith("1.")
+  },
+  args: {
+    install: {
+      command: "add",
+      options: {
+        dev: "-D",
+        preferOffline: "--cached"
+      }
+    },
+    uninstall: {
+      command: "remove"
+    }
+  },
+  options: {
+    version: "--version"
+  }
+});
+
 async function findPackageManager(packageManagers, options) {
   const packageManager = await findPackageManagerSafely(
     packageManagers,
@@ -762,7 +783,9 @@ async function detectPackageManagers(packageManagers, options) {
 async function detectLockfilePackageManagers(packageManagers, options) {
   return filterPackageManagers(
     packageManagers,
-    (packageManager) => packageManager.hasLockfile(options),
+    // Yarn Classic and Berry share a lockfile name, so a lockfile match alone
+    // would report both. The version check settles which one it is.
+    async (packageManager) => await packageManager.hasLockfile(options) && await packageManager.matchesVersion(options),
     options
   );
 }
@@ -772,7 +795,7 @@ async function detectGlobalPackageManagers(packageManagers, options) {
     // Without the `await`, `Boolean` receives a pending promise and is always
     // `true`, so every package manager passes the filter regardless of whether
     // it is actually installed.
-    async (packageManager) => Boolean(await packageManager.globalVersion(options)),
+    async (packageManager) => Boolean(await packageManager.globalVersion(options)) && await packageManager.matchesVersion(options),
     options
   );
 }
@@ -805,7 +828,7 @@ function selectAllowedPackageManagers(packageManagers, options) {
   );
 }
 
-const packageManagerConfigs = [pnpm, yarn, bun, npm];
+const packageManagerConfigs = [pnpm, yarn, yarnBerry, bun, npm];
 function definePackageManagerClient(options) {
   const configs = packageManagerConfigs.map(
     (config) => definePackageManager(config, options)
@@ -835,8 +858,11 @@ function definePackageManagerClient(options) {
   };
 }
 
-function isPackageDependency(packageName) {
-  return toArray(packageName).every((name) => isDependencyInPackageJson(name));
+function isPackageDependency(packageName, options) {
+  const { packageJson } = getPackageInfo(options);
+  return toArray(packageName).every(
+    (name) => isDependencyInPackageJson(name, packageJson)
+  );
 }
 
 function definePathAliases(aliasDefinitions) {
@@ -854,42 +880,49 @@ function definePathAliases(aliasDefinitions) {
   };
 }
 function getAliasedFilePath(aliasMap, options) {
-  const { to, startingFrom, cwd, checkExistence, glob } = typeof options === "string" || Array.isArray(options) ? { to: options } : options;
-  const resolveOptions = { cwd, checkExistence, glob, aliasMap };
+  const { to, startingFrom, cwd, from, checkExistence, glob } = typeof options === "string" || Array.isArray(options) ? { to: options } : options;
+  const resolveOptions = { cwd, from, checkExistence, glob, aliasMap };
   try {
     return startingFrom ? resolveRelativePathTo(to, startingFrom, resolveOptions) : resolvePathTo(to, resolveOptions);
   } catch (error) {
-    if (checkExistence || glob) return void 0;
+    if (error instanceof PathNotFoundError) return void 0;
     throw error;
   }
 }
+class PathNotFoundError extends Error {
+}
 function resolveRelativePathTo(to, from, options) {
   const pathFrom = resolvePathTo(from, options);
   const pathTo = resolvePathTo(to, options);
-  return path$1.relative(pathFrom, pathTo);
+  return path.relative(pathFrom, pathTo);
 }
-function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
-  const normalized = normalizePathTo(pathTo, { cwd, aliasMap });
+function resolvePathTo(pathTo, { cwd, from, checkExistence, glob, aliasMap }) {
+  const normalized = normalizePathTo(pathTo, { cwd, from, aliasMap });
   if (glob) {
     const globPaths = globbySync(normalized, { cwd });
     if (!globPaths[0])
-      throw new Error(`No paths found for glob: ${normalized}`);
+      throw new PathNotFoundError(`No paths found for glob: ${normalized}`);
     return globPaths[0];
   }
   if (!glob && checkExistence && !existsSync(normalized))
-    throw new Error(`Path does not exist: ${normalized}`);
+    throw new PathNotFoundError(`Path does not exist: ${normalized}`);
   return normalized;
 }
 function normalizePathTo(pathTo, options) {
-  const { cwd, aliasMap } = options ?? {};
-  const aliasedPath = Array.isArray(pathTo) ? path$1.join(...pathTo.filter(isNotNull)) : pathTo;
-  const baseDir = Array.isArray(pathTo) ? pathTo[0] : findAliasToken(aliasedPath, aliasMap);
-  if (baseDir === void 0) return aliasedPath;
-  const baseDirPath = executeMapFn(aliasMap, baseDir, [{ cwd }]);
-  if (typeof baseDirPath !== "string" || baseDirPath.length === 0) {
-    throw new Error(`Path alias resolved to no location: ${baseDir}`);
+  const { cwd, from, aliasMap } = options ?? {};
+  const baseDir = Array.isArray(pathTo) ? pathTo[0] : findAliasToken(pathTo, aliasMap);
+  if (baseDir === void 0) return pathTo;
+  const baseDirPath = assertResolved(
+    baseDir,
+    executeMapFn(aliasMap, baseDir, [{ cwd, from }])
+  );
+  return Array.isArray(pathTo) ? path.join(baseDirPath, ...pathTo.slice(1).filter(isNotNull)) : resolveAlias(pathTo, { [baseDir]: baseDirPath });
+}
+function assertResolved(alias, resolved) {
+  if (typeof resolved !== "string" || resolved.length === 0) {
+    throw new Error(`Path alias resolved to no location: ${alias}`);
   }
-  return resolveAlias(aliasedPath, { [baseDir]: baseDirPath });
+  return resolved;
 }
 function findAliasToken(pathTo, aliasMap) {
   return Object.keys(aliasMap ?? {}).filter((alias) => pathTo === alias || pathTo.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length)[0];
@@ -907,10 +940,17 @@ function getAliasMap(aliasDefs) {
       return [
         [alias, resolve],
         ...subpaths.map(({ to }) => {
-          const subpathAlias = path$1.join(alias, to);
+          const subpathAlias = path.join(alias, to);
           return [
             subpathAlias,
-            (opts) => resolveAlias(subpathAlias, { [alias]: resolve(opts) })
+            (opts) => (
+              // The same assertion the bare alias gets. Without it an
+              // unresolvable parent produced `join(undefined, "/node_modules")`
+              // — a path at the filesystem root — instead of failing.
+              resolveAlias(subpathAlias, {
+                [alias]: assertResolved(alias, resolve(opts))
+              })
+            )
           ];
         })
       ];
@@ -985,13 +1025,13 @@ const predefinedPathAliases = {
     subpaths: []
   },
   "<current_file>": {
-    // resolve: () => fileURLToPath(import.meta.url),
-    resolve: () => _filename({ rootFunctionName: "getFilePath" }) ?? "",
+    // `from` is the caller naming itself, which is exact. Without it the stack
+    // is read, which is a best effort and Node-only.
+    resolve: (opts) => _filename({ from: opts?.from, boundaryFunctionName: "getFilePath" }),
     subpaths: []
   },
   "<current_folder>": {
-    // resolve: () => fileURLToPath(import.meta.url),
-    resolve: () => _dirname({ rootFunctionName: "getFilePath" }) ?? "",
+    resolve: (opts) => _dirname({ from: opts?.from, boundaryFunctionName: "getFilePath" }),
     subpaths: []
   }
 };
@@ -1014,59 +1054,65 @@ const jsonSourceResolvers = {
   text: (text) => {
     return {
       text: () => text,
-      data: () => JSON.parse(text)
+      // `jsonc-parser`'s parse, not `JSON.parse`: the whole point of this
+      // module is editing files like tsconfig.json, which carry comments.
+      data: () => parse(text)
     };
   },
   filepath: (filepath) => {
     const text = readFileSync(filepath, "utf-8");
     return {
       text: () => text,
-      data: () => JSON.parse(text)
+      // `jsonc-parser`'s parse, not `JSON.parse`: the whole point of this
+      // module is editing files like tsconfig.json, which carry comments.
+      data: () => parse(text)
     };
   }
 };
 function resolveJsonSource(source, as) {
   const [sourceType, sourceData] = Object.entries(source).find(([_, selected]) => selected !== void 0) ?? [];
-  if (!sourceType || !(sourceType in jsonSourceResolvers) || !sourceData) {
+  if (!sourceType || !(sourceType in jsonSourceResolvers) || sourceData === void 0) {
     throw new Error("Invalid source data");
   }
   const sourceTypeResolvers = jsonSourceResolvers[sourceType](
     sourceData
   );
-  const resolved = morph(sourceTypeResolvers, (key, v) => {
-    try {
-      const value = v();
-      return !as || key === as ? [key, value] : [];
-    } catch (e) {
-      throw new Error(`Failed to resolve ${key} from ${sourceType}`);
-    }
-  });
+  const resolved = fromEntries(
+    entriesOf(sourceTypeResolvers).flatMap(([key, v]) => {
+      if (as && key !== as) return [];
+      try {
+        return [[key, v()]];
+      } catch (error) {
+        throw new Error(`Failed to resolve ${key} from ${sourceType}`, {
+          cause: error
+        });
+      }
+    })
+  );
   if (as) {
     return resolved[as];
   }
   return resolved;
 }
 
+const toPathSegment = (segment) => /^\d+$/.test(segment) ? Number(segment) : segment;
 function resolveEditPath(path, options) {
-  const { pathSeparator = "." } = {};
-  const arr = toArray(path);
-  return arr.map((path2) => {
-    if (typeof path2 === "string") {
-      return pathSeparator === false ? path2 : path2.split(pathSeparator);
-    }
-    return path2;
-  }).flat();
+  const { pathSeparator = "." } = options || {};
+  if (Array.isArray(path)) return path;
+  if (typeof path === "number" || pathSeparator === false) return [path];
+  return path.split(pathSeparator).map(toPathSegment);
 }
-function parseJSONCEdits(edits) {
+function parseJSONCEdits(edits, defaultEditOptions) {
+  const resolve = (path, options) => resolveEditPath(path, { ...defaultEditOptions, ...options });
   if (Array.isArray(edits)) {
     return edits.map(({ path, ...edit }) => ({
-      path: resolveEditPath(path),
+      path: resolve(path, edit.options),
       ...edit
     }));
   }
   return Object.entries(edits).map(
     ([path, value]) => ({
-      path: resolveEditPath(path),
+      path: resolve(path, value.options),
       ...value
     })
   );
@@ -1078,14 +1124,17 @@ function modifyJSON({
 }) {
   return checkResult(() => {
     const text = resolveJsonSource(json, "text");
-    const jsoncEdits = parseJSONCEdits(edits);
-    const editResult = jsoncEdits.flatMap(
-      (edit) => modify(text, edit.path, edit.value, {
-        ...defaultEditOptions,
-        ...edit.options
-      })
+    const jsoncEdits = parseJSONCEdits(edits, defaultEditOptions);
+    const updated = jsoncEdits.reduce(
+      (current, edit) => applyEdits(
+        current,
+        modify(current, edit.path, edit.value, {
+          ...defaultEditOptions,
+          ...edit.options
+        })
+      ),
+      text
     );
-    const updated = applyEdits(text, editResult);
     return resolveJsonSource({ text: updated });
   });
 }
@@ -1120,110 +1169,82 @@ const storage = createStorage({ driver: defineMemoryDriver() });
 const tempFileSystem = defineFileSystemStorage({
   base: join(os.tmpdir(), ".package-manager")
 });
+const encodeEntry = (value) => typeof value === "string" ? value : JSON.stringify(value);
 function defineFileSystemEntries(definition) {
-  const fileSystemEntries = Object.entries(definition).map(([k, v]) => {
-    if (v instanceof Function) {
-      const {
-        file,
-        options,
-        serialize = (input) => JSON.stringify(input),
-        deserialize = (input) => {
-          try {
-            return JSON.parse(input);
-          } catch {
-            return input;
-          }
-        }
-      } = v();
-      return {
-        key: k,
-        value: serialize(file),
-        options,
-        serialize,
-        deserialize
-      };
+  const fileSystemEntries = Object.entries(definition).map(([key, value]) => {
+    if (typeof value === "function") {
+      const { file, options } = value();
+      return { key, value: encodeEntry(file), options };
     }
-    if (isStorageValue(v)) {
-      return {
-        key: k,
-        value: JSON.stringify(v)
-      };
+    if (!isStorageValue(value)) {
+      throw new Error(
+        `Cannot store a ${typeof value} at "${key}": file system entries must be a storage value or a function returning one.`
+      );
     }
-    return void 0;
-  }).filter((v) => v !== void 0);
+    return { key, value: encodeEntry(value) };
+  });
   const resolved = {
     definition,
     fileSystemEntries
   };
   return resolved;
 }
+const keyToFilePath = (root, key) => join(root, ...key.split(/[:/\\]+/).filter(Boolean));
 function defineFileSystemStorage(options) {
   const { base: root, initial, ...storageOptions } = options;
-  let initialFileEntriesData = defineFileSystemEntries(initial ?? {});
+  let entriesData = defineFileSystemEntries(initial ?? {});
   const storage2 = createStorage({
     driver: defineFsLiteDriver({ base: root, ...storageOptions })
   });
+  const getFilePath = (key) => keyToFilePath(root, key);
+  const getFile = async (key) => ({
+    key,
+    filepath: getFilePath(key),
+    data: await storage2.getItem(key),
+    // `getItemRaw` resolves to null for a missing file rather than throwing.
+    read: async () => (await storage2.getItemRaw(key))?.toString()
+  });
+  const removeAllFiles = async () => storage2.clear();
   const fileStorage = {
     createFile: async (key, data) => {
       await storage2.setItem(key, data);
       return {
         key,
-        filepath: join(root, key),
+        filepath: getFilePath(key),
         get: async () => storage2.getItem(key),
         update: async (data2) => storage2.setItem(key, data2)
       };
     },
-    async getFilePath(key) {
-      return (await this.getFile(key)).filepath;
-    },
-    getFile: async (key) => {
-      const storageData = await storage2.getItem(key);
-      return {
-        key,
-        filepath: join(root, key),
-        data: storageData,
-        read: async () => (await storage2.getItemRaw(key))?.toString()
-      };
-    },
-    async readFile(key) {
-      const { read } = await this.getFile(key);
-      const content = await read();
-      return content;
-    },
-    snapshotFs: async (base = root) => {
-      return snapshot(storage2, base);
-    },
-    restoreFs: async (snapshot2) => {
-      return restoreSnapshot(storage2, snapshot2);
-    },
+    getFilePath,
+    getFile,
+    readFile: async (key) => (await getFile(key)).read(),
+    // `base` is a key prefix. Defaulting it to the filesystem root would match
+    // no key at all and silently report an empty filesystem.
+    snapshotFs: async (base = "") => snapshot(storage2, base),
+    restoreFs: async (snapshot2, base) => restoreSnapshot(storage2, snapshot2, base),
     initializeFs: async (override) => {
-      if (override) {
-        initialFileEntriesData = defineFileSystemEntries(override);
-      }
-      await storage2.clear();
-      return storage2.setItems(initialFileEntriesData.fileSystemEntries);
+      const previousKeys = entriesData.fileSystemEntries.map(({ key }) => key);
+      if (override) entriesData = defineFileSystemEntries(override);
+      await Promise.all(previousKeys.map((key) => storage2.removeItem(key)));
+      await storage2.setItems(entriesData.fileSystemEntries);
     },
     defineFileSystemEntries,
-    removeAllFiles: storage2.clear,
+    removeAllFiles,
     async deleteFileSystem() {
-      await this.removeAllFiles();
-      await storage2.unmount(root, true);
+      await removeAllFiles();
+      await storage2.dispose();
       await rm(root, { recursive: true, force: true });
     },
     storage: storage2,
     meta: {
-      fileEntriesData: initialFileEntriesData
+      // A getter, so that `initializeFs(override)` is reflected here rather
+      // than this reporting whatever the definition was at construction.
+      get fileEntriesData() {
+        return entriesData;
+      }
     }
   };
-  if (initial) {
-    return {
-      initialize: async () => {
-        await fileStorage.initializeFs(initial);
-        return fileStorage;
-      }
-    };
-  }
   return fileStorage;
 }
 
-export { _dirname, _filename, defineFileSystemEntries, defineFileSystemStorage, definePackage, definePackageManagerClient, definePathAliases, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, filterPackageManagers, findDependencyInPackageJson, findPackageManager, findPackageManagerSafely, findResolvedModulePath, getAliasMap, getFolderByPackageName, getGitRootFolder, getGlobalVersions, getPackageFolder, getPath, getWorkspaceFolder, importMap, importer, isDependencyInPackageJson, isPackageDependency, isPackageModuleFound, mapPackageManagers, modifyJSON, modifyJSONFile, packageManagerConfigs, predefinedPathAliases, project, resolveModule, resolveModulePath, resolvePackageModulePath, storage, tempFileSystem, workspace };
+export { _dirname, _filename, createFile, defineFileSystemEntries, defineFileSystemStorage, definePackage, definePackageManager, definePackageManagerClient, definePathAliases, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, filterPackageManagers, findDependencyInPackageJson, findPackageManager, findPackageManagerSafely, findResolvedModulePath, getAliasMap, getFolderByPackageName, getGitRootFolder, getGlobalVersions, getPackageFolder, getPath, getWorkspaceFolder, importMap, importer, isDependencyInPackageJson, isPackageDependency, isPackageModuleFound, isWritable, mapPackageManagers, modifyJSON, modifyJSONFile, packageManagerConfigs, predefinedPathAliases, project, resolveModule, resolveModulePath, resolvePackageModulePath, storage, tempFileSystem, workspace };