package-management 0.0.16 → 0.1.0

package/dist/index.cjs

@@ -1,9 +1,7 @@
 'use strict';
 
-const ErrorStackParser = require('error-stack-parser');
 const path = require('pathe');
-const process = require('node:process');
-const path$1 = require('node:path');
+const util = require('node:util');
 const node_url = require('node:url');
 const node_fs = require('node:fs');
 const asyncCacheFn = require('async-cache-fn');
@@ -11,17 +9,19 @@ const execa = require('execa');
 const findUp = require('find-up');
 const promises = require('node:fs/promises');
 const mlly = require('mlly');
+const WST = require('workspace-tools');
+const process = require('node:process');
+const path$1 = require('node:path');
 const globby = require('globby');
 const gitignoreParser = require('parse-gitignore');
-const WST = require('workspace-tools');
 const utils = require('pathe/utils');
 const os = require('node:os');
 const jsoncParser = require('jsonc-parser');
-const util = require('@arktype/util');
 const unstorage = require('unstorage');
 const defineMemoryDriver = require('unstorage/drivers/memory');
 const defineFsLiteDriver = require('unstorage/drivers/fs-lite');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 function _interopNamespaceCompat(e) {
@@ -36,16 +36,80 @@ function _interopNamespaceCompat(e) {
   return n;
 }
 
-const ErrorStackParser__default = /*#__PURE__*/_interopDefaultCompat(ErrorStackParser);
-const path__default$1 = /*#__PURE__*/_interopDefaultCompat(path);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const util__default = /*#__PURE__*/_interopDefaultCompat(util);
+const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
 const process__default = /*#__PURE__*/_interopDefaultCompat(process);
-const path__default = /*#__PURE__*/_interopDefaultCompat(path$1);
+const path__default$1 = /*#__PURE__*/_interopDefaultCompat(path$1);
 const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
-const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
 const os__default = /*#__PURE__*/_interopDefaultCompat(os);
 const defineMemoryDriver__default = /*#__PURE__*/_interopDefaultCompat(defineMemoryDriver);
 const defineFsLiteDriver__default = /*#__PURE__*/_interopDefaultCompat(defineFsLiteDriver);
 
+const getCallSites = "getCallSites" in util__default ? util__default.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 = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href));
+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:") || path.isAbsolute(script));
+const toFilePath = (script) => script.startsWith("file:") ? node_url.fileURLToPath(script) : script;
+function toCallerPath(from) {
+  if (from.startsWith("file:")) return node_url.fileURLToPath(from);
+  if (path.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 : path.dirname(filePath);
+};
+const withOwnScript = (options) => ({
+  ...options,
+  internalScripts: [...options?.internalScripts ?? [], (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))]
+});
+
+function createFile(filePath, data, options) {
+  const { encoding = "utf-8", ...rest } = typeof options === "string" ? { encoding: options } : options ?? {};
+  const dir = path__default.dirname(filePath);
+  const writeFileOptions = { encoding, ...rest };
+  if (!node_fs.existsSync(dir)) {
+    node_fs.mkdirSync(dir, { recursive: true });
+  }
+  node_fs.writeFileSync(filePath, data, writeFileOptions);
+}
+
+function isWritable(filename) {
+  try {
+    node_fs.accessSync(filename, node_fs.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);
@@ -59,7 +123,7 @@ const select = (obj, selection, mode) => {
 };
 function normalizePath(path$1, option) {
   if (typeof option === "function") {
-    return normalizePath(path$1);
+    return option(path$1);
   }
   if (option === false) {
     return path$1;
@@ -71,14 +135,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({
@@ -103,123 +159,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__default.parse(error).reverse() : ErrorStackParser__default.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__default.cwd();
-  const filePath = path.normalize(toFilePath(filepath));
-  const fileBasename = path.basename(filePath);
-  const dirPath = path.dirname(filePath);
-  const dirBasename = path.basename(dirPath);
-  const relativeFilePath = path.relative(workingDir, filePath);
-  const relativeDirPath = path.dirname(relativeFilePath);
-  const isFileInCwd = filePath.startsWith(workingDir);
-  return {
-    filePath,
-    dirPath,
-    relativeFilePath,
-    relativeDirPath,
-    fileBasename,
-    dirBasename,
-    isFileInCwd
-  };
-}
-function toFilePath(fileName) {
-  return fileName.startsWith("file:") ? node_url.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) {
@@ -241,28 +190,68 @@ function resolveModulePath(modulePath, options) {
   }
 }
 
+function getPackageFolder(options) {
+  return WST__namespace.findPackageRoot(options?.cwd ?? process__default.cwd());
+}
+
+function getPackageInfo(options) {
+  const packageDir = getPackageFolder(options);
+  if (!packageDir) {
+    throw new Error(
+      `No package.json found searching up from "${options?.cwd ?? process__default.cwd()}"`
+    );
+  }
+  return readPackageInfo({ packageDir });
+}
+function readPackageInfo({
+  packageDir
+}) {
+  const packageJsonPath = path__default$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 } = node_fs.statSync(packageJsonPath);
+  const cached = packageJsonCache.get(packageJsonPath);
+  if (cached?.mtimeMs === mtimeMs) return cached.packageJson;
+  const packageJson = JSON.parse(
+    node_fs.readFileSync(packageJsonPath, "utf-8")
+  );
+  packageJsonCache.set(packageJsonPath, { mtimeMs, packageJson });
+  return packageJson;
+}
+
 const tsconfig = (tsconfigDir) => ({
   get paths() {
+    if (!tsconfigDir) return [];
     return globby.globbySync(["tsconfig.json", "tsconfig.*.json"], {
-      cwd: tsconfigDir
-    }) ?? [];
+      cwd: tsconfigDir,
+      absolute: true
+    });
   }
 });
 
-function parseGitignoreFile(gitignorePath, options) {
-  return gitignoreParser__default(gitignorePath, options);
+function parseGitignoreContent(gitignoreContent, options) {
+  return gitignoreParser__default(gitignoreContent, options);
 }
-function getGitignoreData(gitignorePath) {
-  const gitignoreFileContent = node_fs.readFileSync(gitignorePath, "utf-8");
-  const gitignores = parseGitignoreFile(gitignoreFileContent);
-  return gitignores;
+function getGitignoreData(gitignorePath, options) {
+  if (!gitignorePath || !node_fs.existsSync(gitignorePath)) {
+    return parseGitignoreContent("", options);
+  }
+  return parseGitignoreContent(node_fs.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;
   }
 });
 
@@ -325,36 +314,13 @@ function getWorkspaceFolder(options) {
     throwIfNotFound = true
   } = options ?? {};
   const getFolder = fallbackToGitRoot ? WST__namespace.findProjectRoot : WST__namespace.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__namespace.findPackageRoot(options?.cwd ?? process__default.cwd());
-}
-
-function getPackageInfo(options) {
-  const packageDir = getPackageFolder(options);
-  return readPackageInfo({ packageDir });
-}
-function readPackageInfo({
-  packageDir
-}) {
-  const packageJsonPath = path__default.join(packageDir, "package.json");
-  const packageJson = JSON.parse(
-    node_fs.readFileSync(packageJsonPath, "utf-8")
-  );
-  return {
-    name: packageJson.name,
-    path: packageJsonPath,
-    dirpath: packageDir,
-    packageJson
-  };
-}
-
 function getWorkspaceProjectInfo(options) {
   try {
     const workspaceDir = getWorkspaceFolder(options);
@@ -370,13 +336,21 @@ function getWorkspacePackageInfoList(options) {
   const wstList = WST__namespace.getWorkspaceInfos(workspaceDir);
   return resolveWstList(wstList);
 }
+function toPackageInfo(info) {
+  return {
+    name: info.name,
+    dirpath: info.path,
+    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,
@@ -393,7 +367,7 @@ function getWorkspacePackageInfoMap(options) {
 
 function getProjectInfoByName(name, options) {
   const { cwd } = options ?? {};
-  return getWorkspacePackageInfoMap({ cwd })[name];
+  return getWorkspacePackageInfoMap({ cwd, includeRoot: true })[name];
 }
 
 function getGitRootFolder(options) {
@@ -408,7 +382,7 @@ function getGitRootFolder(options) {
     }
     return void 0;
   }
-  return path__default$1.normalize(stdout);
+  return path__default.normalize(stdout);
 }
 
 function getProjectInfo(folder, options) {
@@ -439,9 +413,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,
@@ -449,41 +428,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__default$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__default.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) {
@@ -498,18 +465,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) => {
@@ -533,12 +506,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) => {
@@ -560,20 +532,36 @@ function definePackageManager(config, options) {
     const lockfiles = toArray(config.meta.lockfile);
     return await findUp.findUp(lockfiles, { cwd });
   });
+  const globalVersion = asyncCacheFn.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
       });
@@ -617,19 +605,12 @@ function definePackageManager(config, options) {
       if (!lockfilePath) return void 0;
       return promises.readFile(lockfilePath, "utf8");
     }),
-    globalVersion: asyncCacheFn.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.asyncCacheFn(async (...args) => {
+      const { matchesVersion } = config.meta;
+      if (!matchesVersion) return true;
+      const version = await globalVersion.noCache(...args);
+      return version ? matchesVersion(version) : false;
     }),
     definePackage,
     installPackage,
@@ -643,6 +624,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.execa(command, args.filter(notFalsy), {
@@ -665,7 +656,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: {
@@ -676,7 +669,7 @@ const bun = definePackageManagerConfig({
       }
     },
     uninstall: {
-      command: "uninstall"
+      command: "remove"
     }
   },
   options: {
@@ -740,7 +733,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: {
@@ -759,6 +754,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,
@@ -788,7 +810,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
   );
 }
@@ -798,7 +822,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
   );
 }
@@ -831,7 +855,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)
@@ -861,8 +885,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) {
@@ -880,42 +907,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__default$1.relative(pathFrom, pathTo);
+  return path__default.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 = globby.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 && !node_fs.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__default$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__default.join(baseDirPath, ...pathTo.slice(1).filter(isNotNull)) : utils.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 utils.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];
@@ -933,10 +967,17 @@ function getAliasMap(aliasDefs) {
       return [
         [alias, resolve],
         ...subpaths.map(({ to }) => {
-          const subpathAlias = path__default$1.join(alias, to);
+          const subpathAlias = path__default.join(alias, to);
           return [
             subpathAlias,
-            (opts) => utils.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.
+              utils.resolveAlias(subpathAlias, {
+                [alias]: assertResolved(alias, resolve(opts))
+              })
+            )
           ];
         })
       ];
@@ -1011,13 +1052,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: []
   }
 };
@@ -1040,59 +1081,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: () => jsoncParser.parse(text)
     };
   },
   filepath: (filepath) => {
     const text = node_fs.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: () => jsoncParser.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 = util.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
     })
   );
@@ -1104,14 +1151,17 @@ function modifyJSON({
 }) {
   return checkResult(() => {
     const text = resolveJsonSource(json, "text");
-    const jsoncEdits = parseJSONCEdits(edits);
-    const editResult = jsoncEdits.flatMap(
-      (edit) => jsoncParser.modify(text, edit.path, edit.value, {
-        ...defaultEditOptions,
-        ...edit.options
-      })
+    const jsoncEdits = parseJSONCEdits(edits, defaultEditOptions);
+    const updated = jsoncEdits.reduce(
+      (current, edit) => jsoncParser.applyEdits(
+        current,
+        jsoncParser.modify(current, edit.path, edit.value, {
+          ...defaultEditOptions,
+          ...edit.options
+        })
+      ),
+      text
     );
-    const updated = jsoncParser.applyEdits(text, editResult);
     return resolveJsonSource({ text: updated });
   });
 }
@@ -1146,117 +1196,91 @@ const storage = unstorage.createStorage({ driver: defineMemoryDriver__default()
 const tempFileSystem = defineFileSystemStorage({
   base: path.join(os__default.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) => path.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 = unstorage.createStorage({
     driver: defineFsLiteDriver__default({ 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: path.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: path.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 unstorage.snapshot(storage2, base);
-    },
-    restoreFs: async (snapshot2) => {
-      return unstorage.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 = "") => unstorage.snapshot(storage2, base),
+    restoreFs: async (snapshot2, base) => unstorage.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 promises.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;
 }
 
 exports._dirname = _dirname;
 exports._filename = _filename;
+exports.createFile = createFile;
 exports.defineFileSystemEntries = defineFileSystemEntries;
 exports.defineFileSystemStorage = defineFileSystemStorage;
 exports.definePackage = definePackage;
+exports.definePackageManager = definePackageManager;
 exports.definePackageManagerClient = definePackageManagerClient;
 exports.definePathAliases = definePathAliases;
 exports.detectGlobalPackageManagers = detectGlobalPackageManagers;
@@ -1279,6 +1303,7 @@ exports.importer = importer;
 exports.isDependencyInPackageJson = isDependencyInPackageJson;
 exports.isPackageDependency = isPackageDependency;
 exports.isPackageModuleFound = isPackageModuleFound;
+exports.isWritable = isWritable;
 exports.mapPackageManagers = mapPackageManagers;
 exports.modifyJSON = modifyJSON;
 exports.modifyJSONFile = modifyJSONFile;