@vltpkg/cli-js 1.4.0 → 1.5.0

package/{chunk-I7UMHYZX.js → chunk-C6ZVVEFV.js}

@@ -13,1110 +13,34 @@ import {
   graphRun,
   graphRunSync,
   joinDepIDTuple
-} from "./chunk-PLG3OYCX.js";
-import {
-  Spec
-} from "./chunk-5IJTPZXP.js";
+} from "./chunk-F7NPYSI2.js";
 import {
   load,
-  parse as parse2,
+  parse,
   stringify,
   walkUp
 } from "./chunk-HTOTG4TS.js";
 import {
-  I,
-  promiseSpawn,
-  whichSync
-} from "./chunk-U7TEQCBN.js";
+  I
+} from "./chunk-B6RIGNEO.js";
 import {
   ot,
   ts
 } from "./chunk-Y5PA7DVK.js";
 import {
-  Range,
-  Version,
   asManifest,
-  isRange,
-  isSpec,
   longDependencyTypes,
   normalizeManifest,
-  parse,
   parseRange,
   satisfies
-} from "./chunk-FLH4YC6W.js";
+} from "./chunk-6LZM3I4Q.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-PZLD7RTK.js";
-
-// ../../node_modules/.vlt/~npm~err-code@2.0.3/node_modules/err-code/index.js
-var require_err_code = __commonJS({
-  "../../node_modules/.vlt/~npm~err-code@2.0.3/node_modules/err-code/index.js"(exports, module) {
-    "use strict";
-    function assign(obj, props) {
-      for (const key in props) {
-        Object.defineProperty(obj, key, {
-          value: props[key],
-          enumerable: true,
-          configurable: true
-        });
-      }
-      return obj;
-    }
-    function createError(err, code, props) {
-      if (!err || typeof err === "string") {
-        throw new TypeError("Please pass an Error to err-code");
-      }
-      if (!props) {
-        props = {};
-      }
-      if (typeof code === "object") {
-        props = code;
-        code = void 0;
-      }
-      if (code != null) {
-        props.code = code;
-      }
-      try {
-        return assign(err, props);
-      } catch (_) {
-        props.message = err.message;
-        props.stack = err.stack;
-        const ErrClass = function() {
-        };
-        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
-        return assign(new ErrClass(), props);
-      }
-    }
-    module.exports = createError;
-  }
-});
-
-// ../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports, module) {
-    function RetryOperation(timeouts, options) {
-      if (typeof options === "boolean") {
-        options = { forever: options };
-      }
-      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-      this._timeouts = timeouts;
-      this._options = options || {};
-      this._maxRetryTime = options && options.maxRetryTime || Infinity;
-      this._fn = null;
-      this._errors = [];
-      this._attempts = 1;
-      this._operationTimeout = null;
-      this._operationTimeoutCb = null;
-      this._timeout = null;
-      this._operationStart = null;
-      if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-      }
-    }
-    module.exports = RetryOperation;
-    RetryOperation.prototype.reset = function() {
-      this._attempts = 1;
-      this._timeouts = this._originalTimeouts;
-    };
-    RetryOperation.prototype.stop = function() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      this._timeouts = [];
-      this._cachedTimeouts = null;
-    };
-    RetryOperation.prototype.retry = function(err) {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (!err) {
-        return false;
-      }
-      var currentTime = (/* @__PURE__ */ new Date()).getTime();
-      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-      }
-      this._errors.push(err);
-      var timeout = this._timeouts.shift();
-      if (timeout === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(this._errors.length - 1, this._errors.length);
-          this._timeouts = this._cachedTimeouts.slice(0);
-          timeout = this._timeouts.shift();
-        } else {
-          return false;
-        }
-      }
-      var self = this;
-      var timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
-          }
-        }
-        self._fn(self._attempts);
-      }, timeout);
-      if (this._options.unref) {
-        timer.unref();
-      }
-      return true;
-    };
-    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-      this._fn = fn;
-      if (timeoutOps) {
-        if (timeoutOps.timeout) {
-          this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-          this._operationTimeoutCb = timeoutOps.cb;
-        }
-      }
-      var self = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
-      }
-      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
-      this._fn(this._attempts);
-    };
-    RetryOperation.prototype.try = function(fn) {
-      console.log("Using RetryOperation.try() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = function(fn) {
-      console.log("Using RetryOperation.start() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = RetryOperation.prototype.try;
-    RetryOperation.prototype.errors = function() {
-      return this._errors;
-    };
-    RetryOperation.prototype.attempts = function() {
-      return this._attempts;
-    };
-    RetryOperation.prototype.mainError = function() {
-      if (this._errors.length === 0) {
-        return null;
-      }
-      var counts = {};
-      var mainError = null;
-      var mainErrorCount = 0;
-      for (var i = 0; i < this._errors.length; i++) {
-        var error2 = this._errors[i];
-        var message = error2.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-          mainError = error2;
-          mainErrorCount = count;
-        }
-      }
-      return mainError;
-    };
-  }
-});
-
-// ../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/lib/retry.js"(exports) {
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && options.forever,
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.timeouts = function(options) {
-      if (options instanceof Array) {
-        return [].concat(options);
-      }
-      var opts2 = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: Infinity,
-        randomize: false
-      };
-      for (var key in options) {
-        opts2[key] = options[key];
-      }
-      if (opts2.minTimeout > opts2.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-      }
-      var timeouts = [];
-      for (var i = 0; i < opts2.retries; i++) {
-        timeouts.push(this.createTimeout(i, opts2));
-      }
-      if (options && options.forever && !timeouts.length) {
-        timeouts.push(this.createTimeout(i, opts2));
-      }
-      timeouts.sort(function(a, b) {
-        return a - b;
-      });
-      return timeouts;
-    };
-    exports.createTimeout = function(attempt, opts2) {
-      var random = opts2.randomize ? Math.random() + 1 : 1;
-      var timeout = Math.round(random * opts2.minTimeout * Math.pow(opts2.factor, attempt));
-      timeout = Math.min(timeout, opts2.maxTimeout);
-      return timeout;
-    };
-    exports.wrap = function(obj, options, methods) {
-      if (options instanceof Array) {
-        methods = options;
-        options = null;
-      }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
-          }
-        }
-      }
-      for (var i = 0; i < methods.length; i++) {
-        var method = methods[i];
-        var original = obj[method];
-        obj[method] = function retryWrapper(original2) {
-          var op = exports.operation(options);
-          var args = Array.prototype.slice.call(arguments, 1);
-          var callback = args.pop();
-          args.push(function(err) {
-            if (op.retry(err)) {
-              return;
-            }
-            if (err) {
-              arguments[0] = op.mainError();
-            }
-            callback.apply(this, arguments);
-          });
-          op.attempt(function() {
-            original2.apply(obj, args);
-          });
-        }.bind(obj, original);
-        obj[method].options = options;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "../../node_modules/.vlt/~npm~retry@0.12.0/node_modules/retry/index.js"(exports, module) {
-    module.exports = require_retry();
-  }
-});
-
-// ../../node_modules/.vlt/~npm~promise-retry@2.0.1/node_modules/promise-retry/index.js
-var require_promise_retry = __commonJS({
-  "../../node_modules/.vlt/~npm~promise-retry@2.0.1/node_modules/promise-retry/index.js"(exports, module) {
-    "use strict";
-    var errcode = require_err_code();
-    var retry = require_retry2();
-    var hasOwn = Object.prototype.hasOwnProperty;
-    function isRetryError(err) {
-      return err && err.code === "EPROMISERETRY" && hasOwn.call(err, "retried");
-    }
-    function promiseRetry2(fn, options) {
-      var temp;
-      var operation;
-      if (typeof fn === "object" && typeof options === "function") {
-        temp = options;
-        options = fn;
-        fn = temp;
-      }
-      operation = retry.operation(options);
-      return new Promise(function(resolve6, reject) {
-        operation.attempt(function(number) {
-          Promise.resolve().then(function() {
-            return fn(function(err) {
-              if (isRetryError(err)) {
-                err = err.retried;
-              }
-              throw errcode(new Error("Retrying"), "EPROMISERETRY", { retried: err });
-            }, number);
-          }).then(resolve6, function(err) {
-            if (isRetryError(err)) {
-              err = err.retried;
-              if (operation.retry(err || new Error())) {
-                return;
-              }
-            }
-            reject(err);
-          });
-        });
-      });
-    }
-    module.exports = promiseRetry2;
-  }
-});
-
-// ../../src/pick-manifest/src/index.ts
-import { readFileSync } from "node:fs";
-var parsedNodeVersion = Version.parse(process.version);
-var versionCache = /* @__PURE__ */ new Map();
-var MAX_VERSION_CACHE = 32768;
-var parsedVersion = (ver) => {
-  const cached = versionCache.get(ver);
-  if (cached !== void 0 || versionCache.has(ver)) return cached;
-  const parsed = parse(ver);
-  if (versionCache.size >= MAX_VERSION_CACHE) versionCache.clear();
-  versionCache.set(ver, parsed);
-  return parsed;
-};
-var isBefore = (version, before, verTimes) => {
-  if (!verTimes || !version || !before) return true;
-  const time = version && verTimes[version];
-  return !!time && Date.parse(time) <= before;
-};
-var checkList = (value, list) => {
-  if (typeof list === "string") {
-    list = [list];
-  }
-  if (!Array.isArray(list)) return true;
-  if (list.length === 1 && list[0] === "any") {
-    return true;
-  }
-  let negated = 0;
-  let match2 = false;
-  for (const entry of list) {
-    const negate = entry.startsWith("!");
-    const test = negate ? entry.slice(1) : entry;
-    if (negate) {
-      negated++;
-      if (value === test) {
-        return false;
-      }
-    } else {
-      match2 = match2 || value === test;
-    }
-  }
-  return match2 || negated === list.length;
-};
-var isMusl = (file) => file.includes("libc.musl-") || file.includes("ld-musl-");
-var LDD_PATH = "/usr/bin/ldd";
-var getFamilyFromFilesystem = () => {
-  try {
-    const content = readFileSync(LDD_PATH, "utf-8");
-    if (content.includes("musl")) {
-      return "musl";
-    }
-    if (content.includes("GNU C Library")) {
-      return "glibc";
-    }
-    return null;
-  } catch {
-    return void 0;
-  }
-};
-var getFamilyFromReport = () => {
-  try {
-    const processReport = process.report;
-    const originalExclude = processReport.excludeNetwork === true;
-    processReport.excludeNetwork = true;
-    const report = processReport.getReport();
-    processReport.excludeNetwork = originalExclude;
-    if (report?.header?.glibcRuntimeVersion) {
-      return "glibc";
-    }
-    if (Array.isArray(report?.sharedObjects) && report.sharedObjects.some(isMusl)) {
-      return "musl";
-    }
-  } catch {
-  }
-  return null;
-};
-var cachedLibcFamily = void 0;
-var detectLibc = () => {
-  if (cachedLibcFamily !== void 0) {
-    return cachedLibcFamily ?? void 0;
-  }
-  if (process.platform !== "linux") {
-    cachedLibcFamily = null;
-    return void 0;
-  }
-  let family = getFamilyFromFilesystem();
-  if (!family) {
-    family = getFamilyFromReport();
-  }
-  cachedLibcFamily = family;
-  return family ?? void 0;
-};
-var platformCheck = (mani, nodeVersion, wantOs, wantArch, wantLibc) => {
-  const { engines, os, cpu, libc } = mani;
-  if (engines) {
-    const { node } = engines;
-    if (node && !satisfies(nodeVersion, node, true)) {
-      return false;
-    }
-  }
-  if (wantOs && !checkList(wantOs, os)) return false;
-  if (wantArch && !checkList(wantArch, cpu)) return false;
-  if (libc) {
-    const libcFamily = wantLibc ?? detectLibc();
-    if (!libcFamily) return false;
-    if (!checkList(libcFamily, libc)) return false;
-  }
-  return true;
-};
-var versionOk = (packument, version, nodeVersion, os, arch, libc, before) => {
-  const mani = packument.versions[version];
-  if (!mani) return false;
-  const { time } = packument;
-  return isBefore(version, before, time) && platformCheck(mani, nodeVersion, os, arch, libc);
-};
-function pickManifest(packument, wanted, opts2 = {}) {
-  const {
-    tag = "latest",
-    before,
-    "node-version": nodeVersion,
-    os = process.platform,
-    arch = process.arch,
-    libc
-  } = opts2;
-  const nv = !nodeVersion ? parsedNodeVersion : Version.parse(nodeVersion);
-  const libcFamily = libc ?? detectLibc();
-  const {
-    name,
-    time: verTimes,
-    versions: versions2,
-    "dist-tags": distTags2
-  } = packument;
-  const time = before && verTimes ? +new Date(before) : Infinity;
-  let range2 = void 0;
-  let spec = void 0;
-  if (typeof wanted === "object") {
-    if (isSpec(wanted)) {
-      const f = wanted.final;
-      range2 = f.range;
-      spec = f;
-    } else if (isRange(wanted)) {
-      range2 = wanted;
-    }
-  } else {
-    spec = Spec.parse(`${name}@${wanted}`).final;
-    range2 = spec.range;
-  }
-  if (!range2) {
-    if (!spec?.distTag) {
-      throw error(
-        "Only dist-tag or semver range specs are supported",
-        { spec }
-      );
-    }
-    const ver = distTags2[spec.distTag];
-    if (!ver) return void 0;
-    const mani = versions2[ver];
-    if (mani && versionOk(packument, ver, nv, os, arch, libcFamily, time)) {
-      return mani;
-    } else {
-      range2 = new Range(`<=${ver}`);
-    }
-  }
-  if (range2.isAny) range2 = new Range("*", true);
-  const defaultVer = distTags2[tag];
-  const defTagVersion = defaultVer ? Version.parse(defaultVer) : void 0;
-  if (defaultVer && (range2.isAny || defTagVersion?.satisfies(range2)) && versionOk(packument, defaultVer, nv, os, arch, libcFamily, time)) {
-    return versions2[defaultVer];
-  }
-  const keys = Object.keys(versions2);
-  if (!keys.length) {
-    return void 0;
-  }
-  let found = void 0;
-  let foundIsDefTag = false;
-  for (const ver of keys) {
-    if (verTimes && (before ? !isBefore(ver, time, verTimes) : !verTimes[ver])) {
-      continue;
-    }
-    const mani = versions2[ver];
-    const version = parsedVersion(ver);
-    if (!version?.satisfies(range2)) {
-      continue;
-    }
-    const mc = {
-      version,
-      deprecated: !!mani.deprecated,
-      platform: platformCheck(mani, nv, os, arch, libcFamily),
-      prerelease: !!version.prerelease?.length,
-      mani
-    };
-    if (!found) {
-      found = mc;
-      if (defTagVersion?.equals(found.version)) {
-        foundIsDefTag = true;
-      }
-      continue;
-    }
-    const mok = !mc.deprecated && mc.platform;
-    const fok = !found.deprecated && found.platform;
-    if (mok !== fok) {
-      if (mok) {
-        found = mc;
-        foundIsDefTag = !!defTagVersion?.equals(mc.version);
-      }
-    } else if (mc.platform !== found.platform) {
-      if (mc.platform) {
-        found = mc;
-        foundIsDefTag = !!defTagVersion?.equals(mc.version);
-      }
-    } else if (mc.deprecated !== found.deprecated) {
-      if (!mc.deprecated) {
-        found = mc;
-        foundIsDefTag = !!defTagVersion?.equals(mc.version);
-      }
-    } else if (found.prerelease !== mc.prerelease) {
-      if (!mc.prerelease) {
-        found = mc;
-        foundIsDefTag = !!defTagVersion?.equals(mc.version);
-      }
-    } else if (defTagVersion?.equals(mc.version)) {
-      found = mc;
-      foundIsDefTag = true;
-    } else if (mc.version.greaterThan(found.version) && !foundIsDefTag) {
-      found = mc;
-    }
-  }
-  return found?.mani;
-}
-
-// ../../src/git/src/spawn.ts
-var import_promise_retry = __toESM(require_promise_retry(), 1);
-
-// ../../src/git/src/make-error.ts
-var connectionErrorRe = new RegExp(
-  [
-    "remote error: Internal Server Error",
-    "The remote end hung up unexpectedly",
-    "Connection timed out",
-    "Operation timed out",
-    "Failed to connect to .* Timed out",
-    "Connection reset by peer",
-    "SSL_ERROR_SYSCALL",
-    "The requested URL returned error: 503"
-  ].join("|")
-);
-var missingPathspecRe = /pathspec .* did not match any file\(s\) known to git/;
-var makeError = (result) => connectionErrorRe.test(result.stderr) ? [
-  (n) => n < 3,
-  error("A git connection error occurred", result)
-] : missingPathspecRe.test(result.stderr) ? [null, error("The git reference could not be found", result)] : [null, error("An unknown git error occurred", result)];
-
-// ../../src/git/src/opts.ts
-var gitEnv = {
-  GIT_ASKPASS: "echo",
-  GIT_SSH_COMMAND: "ssh -oStrictHostKeyChecking=accept-new"
-};
-var opts = (opts2 = {}) => ({
-  acceptFail: true,
-  ...opts2,
-  env: opts2.env ?? { ...gitEnv, ...process.env },
-  stdio: "pipe",
-  stdioString: true,
-  shell: false
-});
-
-// ../../src/git/src/which.ts
-var gitPath = void 0;
-var which = (opts2 = {}) => {
-  if (opts2.git) {
-    return opts2.git;
-  }
-  let whichError = void 0;
-  if (opts2.git !== false) {
-    if (!gitPath) {
-      try {
-        gitPath = whichSync("git");
-      } catch (er) {
-        whichError = er;
-      }
-    }
-  }
-  if (!gitPath || opts2.git === false) {
-    return error(
-      "No git binary found in $PATH",
-      {
-        code: "ENOGIT",
-        cause: whichError
-      },
-      which
-    );
-  }
-  return gitPath;
-};
-
-// ../../src/git/src/spawn.ts
-var spawn = async (gitArgs, opts2 = {}) => {
-  const gitPath2 = which(opts2);
-  if (gitPath2 instanceof Error) {
-    throw gitPath2;
-  }
-  const args = opts2.allowReplace || gitArgs[0] === "--no-replace-objects" ? gitArgs : ["--no-replace-objects", ...gitArgs];
-  const retryOpts = {
-    retries: opts2["fetch-retries"] || 3,
-    factor: opts2["fetch-retry-factor"] || 2,
-    maxTimeout: opts2["fetch-retry-maxtimeout"] || 6e4,
-    minTimeout: opts2["fetch-retry-mintimeout"] || 1e3
-  };
-  return (0, import_promise_retry.default)(async (retryFn, num) => {
-    const result = await promiseSpawn(gitPath2, args, opts(opts2));
-    if (result.status || result.signal) {
-      const [shouldRetry, gitError] = makeError(result);
-      if (!shouldRetry?.(num)) {
-        throw gitError;
-      }
-      retryFn(gitError);
-    }
-    return result;
-  }, retryOpts);
-};
-
-// ../../src/git/src/is.ts
-import { stat } from "node:fs/promises";
-var is = ({ cwd = process.cwd() } = {}) => stat(cwd + "/.git").then(
-  () => true,
-  () => false
-);
-
-// ../../src/git/src/is-clean.ts
-var isClean = async (opts2 = {}) => {
-  const result = await spawn(
-    ["status", "--porcelain=v1", "-uno"],
-    opts2
-  );
-  if (result.status || result.signal) {
-    throw error("git isClean check failed", result);
-  }
-  for (const line of result.stdout.split(/\r?\n+/)) {
-    if (line.trim()) return false;
-  }
-  return true;
-};
-
-// ../../src/git-scp-url/src/index.ts
-var knownProtocols = /* @__PURE__ */ new Set([
-  "http:",
-  "https:",
-  "git:",
-  "git+ssh:",
-  "git+https:",
-  "ssh:"
-]);
-var memo = /* @__PURE__ */ new Map();
-var correctProtocol = (arg) => {
-  const firstColon = arg.indexOf(":");
-  const proto = arg.slice(0, firstColon + 1);
-  const doubleSlash = arg.indexOf("//");
-  if (knownProtocols.has(proto)) {
-    if (doubleSlash === firstColon + 1) {
-      return arg;
-    }
-    return proto + "//" + arg.slice(firstColon + 1);
-  }
-  const firstAt = arg.indexOf("@");
-  if (firstAt > -1) {
-    if (firstAt > firstColon) {
-      return `git+ssh://${arg}`;
-    } else {
-      return arg;
-    }
-  }
-  return proto + "//" + arg.slice(firstColon + 1);
-};
-var correctUrl = (url) => {
-  const firstAt = url.indexOf("@");
-  const lastHash = url.lastIndexOf("#");
-  let firstColon = url.indexOf(":");
-  let lastColon = url.lastIndexOf(
-    ":",
-    lastHash > -1 ? lastHash : Infinity
-  );
-  let corrected = url;
-  if (lastColon > firstAt) {
-    corrected = url.slice(0, lastColon) + "/" + url.slice(lastColon + 1);
-    firstColon = corrected.indexOf(":");
-    lastColon = corrected.lastIndexOf(":");
-  }
-  if (firstColon === -1 && !url.includes("//")) {
-    corrected = `git+ssh://${corrected}`;
-  }
-  return corrected;
-};
-var gitScpURL = (url) => {
-  const memoized = memo.get(url);
-  if (memoized) return memoized;
-  try {
-    const result = new URL(url);
-    if (result.hostname) {
-      memo.set(url, result);
-      return result;
-    }
-  } catch {
-  }
-  try {
-    const result = new URL(correctUrl(correctProtocol(url)));
-    if (result.hostname) {
-      memo.set(url, result);
-      return result;
-    }
-  } catch {
-  }
-  return void 0;
-};
-
-// ../../src/git/src/clone.ts
-import { mkdir, stat as stat2 } from "node:fs/promises";
-import { basename, resolve as resolve2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// ../../src/git/src/is-windows.ts
-var isWindows = (opts2) => (opts2.fakePlatform || process.platform) === "win32";
-
-// ../../src/git/src/revs.ts
-import { fileURLToPath } from "node:url";
-
-// ../../src/git/src/lines-to-revs.ts
-var linesToRevs = (lines) => finish(
-  lines.reduce(linesToRevsReducer, {
-    name: "",
-    versions: {},
-    "dist-tags": {},
-    refs: {},
-    shas: {}
-  })
-);
-var finish = (revs2) => distTags(versions(shaList(peelTags(revs2))));
-var versions = (revs2) => {
-  for (const [version, entry] of Object.entries(revs2.versions)) {
-    entry.version = version;
-  }
-  return revs2;
-};
-var shaList = (revs2) => {
-  Object.entries(revs2.refs).forEach(([ref, doc]) => {
-    const shas = revs2.shas[doc.sha];
-    if (!shas) {
-      revs2.shas[doc.sha] = [ref];
-    } else {
-      shas.push(ref);
-    }
-  });
-  return revs2;
-};
-var peelTags = (revs2) => {
-  Object.entries(revs2.refs).filter(([ref]) => ref.endsWith("^{}")).forEach(([ref, peeled]) => {
-    const unpeeled = revs2.refs[ref.replace(/\^\{\}$/, "")];
-    if (unpeeled) {
-      unpeeled.sha = peeled.sha;
-      delete revs2.refs[ref];
-    }
-  });
-  return revs2;
-};
-var distTags = (revs2) => {
-  const HEAD = revs2.refs.HEAD ?? {
-    sha: void 0
-  };
-  for (const [v, ver] of Object.entries(revs2.versions)) {
-    if (ver.sha === revs2.refs.latest?.sha) {
-      revs2["dist-tags"].latest = v;
-    } else if (ver.sha === HEAD.sha) {
-      revs2["dist-tags"].HEAD = v;
-      if (!revs2.refs.latest) {
-        revs2["dist-tags"].latest = v;
-      }
-    }
-  }
-  return revs2;
-};
-var refType = (ref) => {
-  if (ref.startsWith("refs/tags/")) {
-    return "tag";
-  }
-  if (ref.startsWith("refs/heads/")) {
-    return "branch";
-  }
-  if (ref.startsWith("refs/pull/")) {
-    return "pull";
-  }
-  if (ref === "HEAD") {
-    return "head";
-  }
-  return "other";
-};
-var lineToRevDoc = (line) => {
-  let [sha, rawRef] = line.trim().split(/\s+/, 2);
-  if (sha === void 0 || rawRef === void 0) return void 0;
-  sha = sha.trim();
-  rawRef = rawRef.trim();
-  const type = refType(rawRef);
-  switch (type) {
-    case "tag": {
-      const ref = rawRef.slice("refs/tags/".length);
-      return { name: "", version: "", sha, ref, rawRef, type };
-    }
-    case "branch": {
-      const ref = rawRef.slice("refs/heads/".length);
-      return { name: "", version: "", sha, ref, rawRef, type };
-    }
-    case "pull": {
-      const ref = rawRef.slice("refs/".length).replace(/\/head$/, "");
-      return { name: "", version: "", sha, ref, rawRef, type };
-    }
-    case "head": {
-      const ref = "HEAD";
-      return { name: "", version: "", sha, ref, rawRef, type };
-    }
-    default:
-      return { name: "", version: "", sha, ref: rawRef, rawRef, type };
-  }
-};
-var linesToRevsReducer = (revs2, line) => {
-  const doc = lineToRevDoc(line);
-  if (!doc) {
-    return revs2;
-  }
-  revs2.refs[doc.ref] = doc;
-  revs2.refs[doc.rawRef] = doc;
-  if (doc.type === "tag") {
-    const match2 = doc.ref.endsWith("^{}") ? null : /v?(\d+\.\d+\.\d+(?:[-+].+)?)$/.exec(doc.ref);
-    if (match2) {
-      if (!match2[1])
-        throw error(`invalid semver tag`, { found: doc.ref });
-      const v = parse(match2[1]);
-      if (v) revs2.versions[String(v)] = doc;
-    }
-  }
-  return revs2;
-};
-
-// ../../src/git/src/revs.ts
-var fetchMethod = async (repo, _, options) => {
-  const result = await spawn(["ls-remote", repo], options.context);
-  const revsDoc = linesToRevs(result.stdout.split("\n"));
-  return revsDoc;
-};
-var revsCache = new I({
-  max: 100,
-  ttl: 5 * 60 * 1e3,
-  allowStaleOnFetchAbort: true,
-  allowStaleOnFetchRejection: true,
-  fetchMethod
-});
-var revs = async (repo, opts2 = {}) => {
-  repo = String(gitScpURL(repo) ?? repo).replace(/^git\+/, "");
-  if (repo.startsWith("file://")) repo = fileURLToPath(repo);
-  if (opts2.noGitRevCache) {
-    const result = await fetchMethod(repo, void 0, {
-      context: opts2
-    });
-    revsCache.set(repo, result);
-    return result;
-  }
-  return await revsCache.fetch(repo, { context: opts2 });
-};
-
-// ../../src/git/src/resolve.ts
-var resolve = async (repo, ref = "HEAD", opts2 = {}) => {
-  const revDoc = await revs(repo, opts2);
-  if (!revDoc) return void 0;
-  return resolveRef(revDoc, ref, opts2);
-};
-var resolveRef = (revDoc, ref = "HEAD", opts2 = {}) => {
-  const { spec } = opts2;
-  ref = spec?.gitCommittish || ref;
-  if (spec?.range) {
-    return pickManifest(revDoc, spec.range, opts2);
-  }
-  if (!ref) {
-    return revDoc.refs.HEAD;
-  }
-  if (revDoc.refs[ref]) {
-    return revDoc.refs[ref];
-  }
-  const sha = revDoc.shas[ref]?.[0];
-  if (sha) {
-    return revDoc.refs[sha];
-  }
-  return void 0;
-};
-
-// ../../src/git/src/clone.ts
-var shallowHosts = /* @__PURE__ */ new Set([
-  "github.com",
-  "gist.github.com",
-  "gitlab.com",
-  "bitbucket.com",
-  "bitbucket.org"
-]);
-var clone = async (repo, ref = "HEAD", target, opts2 = {}) => {
-  repo = String(gitScpURL(repo) ?? repo).replace(/^git\+/, "");
-  if (repo.startsWith("file://")) repo = fileURLToPath2(repo);
-  const revs2 = await revs(repo, opts2);
-  return await clone_(
-    repo,
-    revs2,
-    ref,
-    revs2 && resolveRef(revs2, ref, opts2),
-    target || defaultTarget(repo, opts2.cwd),
-    opts2
-  );
-};
-var maybeShallow = (repo, opts2) => {
-  if (opts2["git-shallow"] === false || opts2["git-shallow"]) {
-    return opts2["git-shallow"];
-  }
-  const host = gitScpURL(repo)?.host ?? "";
-  return shallowHosts.has(host);
-};
-var defaultTarget = (repo, cwd = process.cwd()) => resolve2(cwd, basename(repo.replace(/[/\\]?\.git$/, "")));
-var clone_ = (repo, revs2, ref, revDoc, target, opts2) => {
-  if (!revDoc || !revs2) {
-    return unresolved(repo, ref, target, opts2);
-  }
-  if (revDoc.sha === revs2.refs.HEAD?.sha) {
-    return plain(repo, revDoc, target, opts2);
-  }
-  if (revDoc.type === "tag" || revDoc.type === "branch") {
-    return branch(repo, revDoc, target, opts2);
-  }
-  return other(repo, revDoc, target, opts2);
-};
-var other = async (repo, revDoc, target, opts2) => {
-  const shallow = maybeShallow(repo, opts2);
-  const fetchOrigin = ["fetch", "origin", revDoc.rawRef].concat(
-    shallow ? ["--depth=1"] : []
-  );
-  const git = (args) => spawn(args, { ...opts2, cwd: target });
-  await mkdir(target, { recursive: true });
-  await git(["init"]);
-  if (isWindows(opts2)) {
-    await git([
-      "config",
-      "--local",
-      "--add",
-      "core.longpaths",
-      "true"
-    ]);
-  }
-  await git(["remote", "add", "origin", repo]);
-  await git(fetchOrigin);
-  await git(["checkout", revDoc.sha]);
-  await updateSubmodules(target, opts2);
-  return revDoc.sha;
-};
-var branch = async (repo, revDoc, target, opts2) => {
-  const args = [
-    "clone",
-    "-b",
-    revDoc.ref,
-    repo,
-    target,
-    "--recurse-submodules"
-  ];
-  if (maybeShallow(repo, opts2)) {
-    args.push("--depth=1");
-  }
-  if (isWindows(opts2)) {
-    args.push("--config", "core.longpaths=true");
-  }
-  await spawn(args, opts2);
-  return revDoc.sha;
-};
-var plain = async (repo, revDoc, target, opts2) => {
-  const args = ["clone", repo, target, "--recurse-submodules"];
-  if (maybeShallow(repo, opts2)) {
-    args.push("--depth=1");
-  }
-  if (isWindows(opts2)) {
-    args.push("--config", "core.longpaths=true");
-  }
-  await spawn(args, opts2);
-  return revDoc.sha;
-};
-var updateSubmodules = async (target, opts2) => {
-  const hasSubmodules = await stat2(`${target}/.gitmodules`).then(() => true).catch(() => false);
-  if (!hasSubmodules) {
-    return;
-  }
-  await spawn(
-    ["submodule", "update", "-q", "--init", "--recursive"],
-    { ...opts2, cwd: target }
-  );
-};
-var unresolved = async (repo, ref, target, opts2) => {
-  const lp = isWindows(opts2) ? ["--config", "core.longpaths=true"] : [];
-  const cloneArgs = [
-    "clone",
-    "--mirror",
-    "-q",
-    repo,
-    target + "/.git"
-  ];
-  const git = (args) => spawn(args, { ...opts2, cwd: target });
-  await mkdir(target, { recursive: true });
-  await git(cloneArgs.concat(lp));
-  await git(["init"]);
-  await git(["checkout", ref]);
-  await updateSubmodules(target, opts2);
-  const result = await git(["rev-parse", "--revs-only", "HEAD"]);
-  return result.stdout;
-};
-
-// ../../src/git/src/user.ts
-var getUser = async (opts2 = {}) => {
-  let name = "";
-  let email = "";
-  const oldFlagUserNameResult = await spawn(
-    ["config", "--get", "user.name"],
-    opts2
-  );
-  if (oldFlagUserNameResult.status || oldFlagUserNameResult.signal) {
-    const userNameResult = await spawn(
-      ["config", "get", "user.name"],
-      opts2
-    );
-    name = userNameResult.status || userNameResult.signal ? "" : userNameResult.stdout.trim();
-  } else {
-    name = oldFlagUserNameResult.stdout.trim();
-  }
-  const oldFlagUserEmailResult = await spawn(
-    ["config", "--get", "user.email"],
-    opts2
-  );
-  if (oldFlagUserEmailResult.status || oldFlagUserEmailResult.signal) {
-    const userEmailResult = await spawn(
-      ["config", "get", "user.email"],
-      opts2
-    );
-    email = userEmailResult.status || userEmailResult.signal ? "" : userEmailResult.stdout.trim();
-  } else {
-    email = oldFlagUserEmailResult.stdout.trim();
-  }
-  if (!name && !email) {
-    return void 0;
-  }
-  return {
-    name,
-    email
-  };
-};
 
 // ../../src/package-json/src/index.ts
-import { readFileSync as readFileSync2, writeFileSync, lstatSync } from "node:fs";
-import { resolve as resolve3 } from "node:path";
+import { readFileSync, writeFileSync, lstatSync } from "node:fs";
+import { resolve } from "node:path";
 import { homedir } from "node:os";
 var exists = (path2) => {
   try {
@@ -1148,7 +72,7 @@ var PackageJson = class {
     if (cachedPackageJson) {
       return cachedPackageJson;
     }
-    const filename = dir.endsWith("package.json") ? resolve3(dir) : resolve3(dir, "package.json");
+    const filename = dir.endsWith("package.json") ? resolve(dir) : resolve(dir, "package.json");
     const fail = (err) => error("Could not read package.json file", err, this.read);
     const cachedError = !reload && this.#errCache.get(dir);
     if (cachedError) {
@@ -1157,7 +81,7 @@ var PackageJson = class {
     try {
       const res = normalizeManifest(
         asManifest(
-          parse2(readFileSync2(filename, { encoding: "utf8" }))
+          parse(readFileSync(filename, { encoding: "utf8" }))
         ),
         filename
       );
@@ -1185,7 +109,7 @@ var PackageJson = class {
     }
   }
   write(dir, manifest, indent) {
-    const filename = dir.endsWith("package.json") ? resolve3(dir) : resolve3(dir, "package.json");
+    const filename = dir.endsWith("package.json") ? resolve(dir) : resolve(dir, "package.json");
     this.fix(manifest);
     try {
       writeFileSync(filename, stringify(manifest, void 0, indent));
@@ -1237,7 +161,7 @@ var PackageJson = class {
   find(cwd = process.cwd(), home = homedir()) {
     for (const dir of walkUp(cwd)) {
       if (dir === home) break;
-      const packageJsonPath = resolve3(dir, "package.json");
+      const packageJsonPath = resolve(dir, "package.json");
       if (exists(packageJsonPath)) {
         return packageJsonPath;
       }
@@ -2669,9 +1593,9 @@ var Minimatch = class {
           }
           didSomething = true;
           parts.splice(gs, 1);
-          const other2 = parts.slice(0);
-          other2[gs] = "**";
-          globParts.push(other2);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
           gs--;
         }
         if (!this.preserveMultipleSlashes) {
@@ -2731,10 +1655,10 @@ var Minimatch = class {
     let ai = 0;
     let bi = 0;
     let result = [];
-    let which2 = "";
+    let which = "";
     while (ai < a.length && bi < b.length) {
       if (a[ai] === b[bi]) {
-        result.push(which2 === "b" ? b[bi] : a[ai]);
+        result.push(which === "b" ? b[bi] : a[ai]);
         ai++;
         bi++;
       } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
@@ -2744,16 +1668,16 @@ var Minimatch = class {
         result.push(b[bi]);
         bi++;
       } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
-        if (which2 === "b")
+        if (which === "b")
           return false;
-        which2 = "a";
+        which = "a";
         result.push(a[ai]);
         ai++;
         bi++;
       } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
-        if (which2 === "a")
+        if (which === "a")
           return false;
-        which2 = "b";
+        which = "b";
         result.push(b[bi]);
         ai++;
         bi++;
@@ -3102,7 +2026,7 @@ minimatch.unescape = unescape;
 
 // ../../node_modules/.vlt/~npm~path-scurry@2.0.2/node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath } from "node:url";
 import { lstatSync as lstatSync2, readdir as readdirCB, readdirSync, readlinkSync, realpathSync as rps } from "node:fs";
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
@@ -3160,10 +2084,10 @@ var Pipe = class {
   dest;
   opts;
   ondrain;
-  constructor(src, dest, opts2) {
+  constructor(src, dest, opts) {
     this.src = src;
     this.dest = dest;
-    this.opts = opts2;
+    this.opts = opts;
     this.ondrain = () => src[RESUME]();
     this.dest.on("drain", this.ondrain);
   }
@@ -3186,8 +2110,8 @@ var PipeProxyErrors = class extends Pipe {
     this.src.removeListener("error", this.proxyErrors);
     super.unpipe();
   }
-  constructor(src, dest, opts2) {
-    super(src, dest, opts2);
+  constructor(src, dest, opts) {
+    super(src, dest, opts);
     this.proxyErrors = (er) => this.dest.emit("error", er);
     src.on("error", this.proxyErrors);
   }
@@ -3560,22 +2484,22 @@ var Minipass = class extends EventEmitter {
    *
    * Triggers the flow of data.
    */
-  pipe(dest, opts2) {
+  pipe(dest, opts) {
     if (this[DESTROYED])
       return dest;
     this[DISCARDED] = false;
     const ended = this[EMITTED_END];
-    opts2 = opts2 || {};
+    opts = opts || {};
     if (dest === proc.stdout || dest === proc.stderr)
-      opts2.end = false;
+      opts.end = false;
     else
-      opts2.end = opts2.end !== false;
-    opts2.proxyErrors = !!opts2.proxyErrors;
+      opts.end = opts.end !== false;
+    opts.proxyErrors = !!opts.proxyErrors;
     if (ended) {
-      if (opts2.end)
+      if (opts.end)
         dest.end();
     } else {
-      this[PIPES].push(!opts2.proxyErrors ? new Pipe(this, dest, opts2) : new PipeProxyErrors(this, dest, opts2));
+      this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
       if (this[ASYNC])
         defer(() => this[RESUME]());
       else
@@ -3836,10 +2760,10 @@ var Minipass = class extends EventEmitter {
    * Return a void Promise that resolves once the stream ends.
    */
   async promise() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve4, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve6());
+      this.on("end", () => resolve4());
     });
   }
   /**
@@ -3863,7 +2787,7 @@ var Minipass = class extends EventEmitter {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve6;
+      let resolve4;
       let reject;
       const onerr = (er) => {
         this.off("data", ondata);
@@ -3877,19 +2801,19 @@ var Minipass = class extends EventEmitter {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve6({ value, done: !!this[EOF] });
+        resolve4({ value, done: !!this[EOF] });
       };
       const onend = () => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve6({ done: true, value: void 0 });
+        resolve4({ done: true, value: void 0 });
       };
       const ondestroy = () => onerr(new Error("stream destroyed"));
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve6 = res2;
+        resolve4 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -4217,7 +3141,7 @@ var PathBase = class {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts2) {
+  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
     this.name = name;
     this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
     this.#type = type & TYPEMASK;
@@ -4225,14 +3149,14 @@ var PathBase = class {
     this.roots = roots;
     this.root = root || this;
     this.#children = children;
-    this.#fullpath = opts2.fullpath;
-    this.#relative = opts2.relative;
-    this.#relativePosix = opts2.relativePosix;
-    this.parent = opts2.parent;
+    this.#fullpath = opts.fullpath;
+    this.#relative = opts.relative;
+    this.#relativePosix = opts.relativePosix;
+    this.parent = opts.parent;
     if (this.parent) {
       this.#fs = this.parent.#fs;
     } else {
-      this.#fs = fsFromOption(opts2.fs);
+      this.#fs = fsFromOption(opts.fs);
     }
   }
   /**
@@ -4304,7 +3228,7 @@ var PathBase = class {
    *
    * @internal
    */
-  child(pathPart, opts2) {
+  child(pathPart, opts) {
     if (pathPart === "" || pathPart === ".") {
       return this;
     }
@@ -4321,7 +3245,7 @@ var PathBase = class {
     const s = this.parent ? this.sep : "";
     const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : void 0;
     const pchild = this.newChild(pathPart, UNKNOWN, {
-      ...opts2,
+      ...opts,
       parent: this,
       fullpath
     });
@@ -4865,9 +3789,9 @@ var PathBase = class {
     if (this.#asyncReaddirInFlight) {
       await this.#asyncReaddirInFlight;
     } else {
-      let resolve6 = () => {
+      let resolve4 = () => {
       };
-      this.#asyncReaddirInFlight = new Promise((res) => resolve6 = res);
+      this.#asyncReaddirInFlight = new Promise((res) => resolve4 = res);
       try {
         for (const e of await this.#fs.promises.readdir(fullpath, {
           withFileTypes: true
@@ -4880,7 +3804,7 @@ var PathBase = class {
         children.provisional = 0;
       }
       this.#asyncReaddirInFlight = void 0;
-      resolve6();
+      resolve4();
     }
     return children.slice(0, children.provisional);
   }
@@ -5001,14 +3925,14 @@ var PathWin32 = class _PathWin32 extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts2) {
-    super(name, type, root, roots, nocase, children, opts2);
+  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+    super(name, type, root, roots, nocase, children, opts);
   }
   /**
    * @internal
    */
-  newChild(name, type = UNKNOWN, opts2 = {}) {
-    return new _PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts2);
+  newChild(name, type = UNKNOWN, opts = {}) {
+    return new _PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
   }
   /**
    * @internal
@@ -5054,8 +3978,8 @@ var PathPosix = class _PathPosix extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts2) {
-    super(name, type, root, roots, nocase, children, opts2);
+  constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+    super(name, type, root, roots, nocase, children, opts);
   }
   /**
    * @internal
@@ -5072,8 +3996,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  newChild(name, type = UNKNOWN, opts2 = {}) {
-    return new _PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts2);
+  newChild(name, type = UNKNOWN, opts = {}) {
+    return new _PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
   }
 };
 var PathScurryBase = class {
@@ -5113,7 +4037,7 @@ var PathScurryBase = class {
   constructor(cwd = process.cwd(), pathImpl, sep3, { nocase, childrenCacheSize = 16 * 1024, fs = defaultFS } = {}) {
     this.#fs = fsFromOption(fs);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
-      cwd = fileURLToPath3(cwd);
+      cwd = fileURLToPath(cwd);
     }
     const cwdPath = pathImpl.resolve(cwd);
     this.roots = /* @__PURE__ */ Object.create(null);
@@ -5260,16 +4184,16 @@ var PathScurryBase = class {
     }
     return (entry.parent || entry).fullpath();
   }
-  async readdir(entry = this.cwd, opts2 = {
+  async readdir(entry = this.cwd, opts = {
     withFileTypes: true
   }) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes } = opts2;
+    const { withFileTypes } = opts;
     if (!entry.canReaddir()) {
       return [];
     } else {
@@ -5277,16 +4201,16 @@ var PathScurryBase = class {
       return withFileTypes ? p : p.map((e) => e.name);
     }
   }
-  readdirSync(entry = this.cwd, opts2 = {
+  readdirSync(entry = this.cwd, opts = {
     withFileTypes: true
   }) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true } = opts2;
+    const { withFileTypes = true } = opts;
     if (!entry.canReaddir()) {
       return [];
     } else if (withFileTypes) {
@@ -5373,14 +4297,14 @@ var PathScurryBase = class {
     const e = entry.realpathSync();
     return withFileTypes ? e : e?.fullpath();
   }
-  async walk(entry = this.cwd, opts2 = {}) {
+  async walk(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts2;
+    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
     const results = [];
     if (!filter2 || filter2(entry)) {
       results.push(withFileTypes ? entry : entry.fullpath());
@@ -5425,14 +4349,14 @@ var PathScurryBase = class {
       });
     });
   }
-  walkSync(entry = this.cwd, opts2 = {}) {
+  walkSync(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts2;
+    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
     const results = [];
     if (!filter2 || filter2(entry)) {
       results.push(withFileTypes ? entry : entry.fullpath());
@@ -5487,14 +4411,14 @@ var PathScurryBase = class {
   [Symbol.iterator]() {
     return this.iterateSync();
   }
-  *iterateSync(entry = this.cwd, opts2 = {}) {
+  *iterateSync(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts2;
+    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
     if (!filter2 || filter2(entry)) {
       yield withFileTypes ? entry : entry.fullpath();
     }
@@ -5518,14 +4442,14 @@ var PathScurryBase = class {
       }
     }
   }
-  stream(entry = this.cwd, opts2 = {}) {
+  stream(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts2;
+    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
     const results = new Minipass({ objectMode: true });
     if (!filter2 || filter2(entry)) {
       results.write(withFileTypes ? entry : entry.fullpath());
@@ -5587,14 +4511,14 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  streamSync(entry = this.cwd, opts2 = {}) {
+  streamSync(entry = this.cwd, opts = {}) {
     if (typeof entry === "string") {
       entry = this.cwd.resolve(entry);
     } else if (!(entry instanceof PathBase)) {
-      opts2 = entry;
+      opts = entry;
       entry = this.cwd;
     }
-    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts2;
+    const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
     const results = new Minipass({ objectMode: true });
     const dirs = /* @__PURE__ */ new Set();
     if (!filter2 || filter2(entry)) {
@@ -5652,9 +4576,9 @@ var PathScurryWin32 = class extends PathScurryBase {
    * separator for generating path strings
    */
   sep = "\\";
-  constructor(cwd = process.cwd(), opts2 = {}) {
-    const { nocase = true } = opts2;
-    super(cwd, win32, "\\", { ...opts2, nocase });
+  constructor(cwd = process.cwd(), opts = {}) {
+    const { nocase = true } = opts;
+    super(cwd, win32, "\\", { ...opts, nocase });
     this.nocase = nocase;
     for (let p = this.cwd; p; p = p.parent) {
       p.nocase = this.nocase;
@@ -5684,9 +4608,9 @@ var PathScurryPosix = class extends PathScurryBase {
    * separator for generating path strings
    */
   sep = "/";
-  constructor(cwd = process.cwd(), opts2 = {}) {
-    const { nocase = false } = opts2;
-    super(cwd, posix, "/", { ...opts2, nocase });
+  constructor(cwd = process.cwd(), opts = {}) {
+    const { nocase = false } = opts;
+    super(cwd, posix, "/", { ...opts, nocase });
     this.nocase = nocase;
   }
   /**
@@ -5709,20 +4633,20 @@ var PathScurryPosix = class extends PathScurryBase {
   }
 };
 var PathScurryDarwin = class extends PathScurryPosix {
-  constructor(cwd = process.cwd(), opts2 = {}) {
-    const { nocase = true } = opts2;
-    super(cwd, { ...opts2, nocase });
+  constructor(cwd = process.cwd(), opts = {}) {
+    const { nocase = true } = opts;
+    super(cwd, { ...opts, nocase });
   }
 };
 var Path = process.platform === "win32" ? PathWin32 : PathPosix;
 var PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
 
 // ../../src/workspaces/src/index.ts
-import { basename as basename2, posix as posix2, resolve as resolve5 } from "node:path";
+import { basename, posix as posix2, resolve as resolve3 } from "node:path";
 
 // ../../src/workspaces/src/pnpm-workspace.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
 var sep2 = (prev, flow) => !prev || (flow ? /[\s[,]/ : /\s/).test(prev);
 var skipQuoted = (s, i) => {
   const q = s.charAt(i);
@@ -5827,8 +4751,8 @@ var parsePnpmWorkspacePackages = (yaml) => {
 var readPnpmWorkspacePackages = (projectRoot) => {
   let yaml;
   try {
-    yaml = readFileSync3(
-      resolve4(projectRoot, "pnpm-workspace.yaml"),
+    yaml = readFileSync2(
+      resolve2(projectRoot, "pnpm-workspace.yaml"),
       "utf8"
     );
   } catch {
@@ -5925,11 +4849,16 @@ var asManifestWSConfig = (conf, path2) => {
   }
   return asWSConfig(conf, path2);
 };
-var resolveWSConfig = (projectRoot, packageJson = new PackageJson()) => {
+var vltJsonOnly = false;
+var setVltJsonOnly = (value) => {
+  vltJsonOnly = value;
+};
+var resolveWSConfig = (projectRoot, packageJson = new PackageJson(), vltJsonOnlyArg = vltJsonOnly) => {
   const fromVltJson = load("workspaces", assertWSConfig);
   if (fromVltJson !== void 0) {
     return { config: asWSConfig(fromVltJson), source: "vlt.json" };
   }
+  if (vltJsonOnlyArg) return { config: {} };
   const workspaces = packageJson.maybeRead(projectRoot)?.workspaces;
   if (workspaces === void 0) {
     const packages = readPnpmWorkspacePackages(projectRoot);
@@ -5938,11 +4867,15 @@ var resolveWSConfig = (projectRoot, packageJson = new PackageJson()) => {
   return {
     config: asManifestWSConfig(
       workspaces,
-      resolve5(projectRoot, "package.json")
+      resolve3(projectRoot, "package.json")
     ),
     source: "package.json"
   };
 };
+var migratableWSConfig = ({
+  config,
+  source
+}) => source && source !== "vlt.json" ? Object.values(config).flat() : void 0;
 var splitNegatedPatterns = (all) => {
   const patterns = [];
   let ignore = [];
@@ -5976,7 +4909,7 @@ var Monorepo = class _Monorepo {
     return [...this.values()].length;
   }
   constructor(projectRoot, options = {}) {
-    this.projectRoot = resolve5(projectRoot);
+    this.projectRoot = resolve3(projectRoot);
     this.scurry = options.scurry ?? new PathScurry(projectRoot);
     this.packageJson = options.packageJson ?? new PackageJson();
     this.#config = options.config;
@@ -6064,7 +4997,7 @@ var Monorepo = class _Monorepo {
   // Either load a workspace from disk, or from our internal set,
   // and assign it to the named group
   #loadWS(path2, group) {
-    const fullpath = resolve5(this.projectRoot, path2);
+    const fullpath = resolve3(this.projectRoot, path2);
     const loaded = this.#workspaces.get(fullpath);
     if (loaded) return loaded;
     const fromCache = workspaceCache.get(fullpath);
@@ -6103,7 +5036,7 @@ var Monorepo = class _Monorepo {
       scurry: this.scurry,
       withFileTypes: false,
       ignore: {
-        childrenIgnored: (p) => basename2(p.relativePosix()) === "node_modules" || // only prunes the subtree for a `!foo/**` style negation,
+        childrenIgnored: (p) => basename(p.relativePosix()) === "node_modules" || // only prunes the subtree for a `!foo/**` style negation,
         // matching npm -- a bare `!foo` still gets walked into
         !!ignore?.childrenIgnored(p) || inMatches(p),
         // ignore if fails to load package.json
@@ -6166,7 +5099,7 @@ var Monorepo = class _Monorepo {
         throw error(
           `Failed to parse package.json in workspace "${rel}"`,
           {
-            path: resolve5(this.projectRoot, rel, "package.json"),
+            path: resolve3(this.projectRoot, rel, "package.json"),
             cause: err
           }
         );
@@ -6397,7 +5330,7 @@ var Workspace = class {
     this.path = path2;
     this.fullpath = fullpath;
     this.manifest = manifest;
-    this.name = manifest.name ?? basename2(path2);
+    this.name = manifest.name ?? basename(path2);
   }
   get keys() {
     if (this.#keys) {
@@ -6409,21 +5342,13 @@ var Workspace = class {
 };
 
 export {
-  detectLibc,
-  platformCheck,
-  pickManifest,
-  spawn,
-  revs,
-  resolve,
-  clone,
-  is,
-  isClean,
-  getUser,
   PackageJson,
   minimatch,
   PathScurry,
   assertWSConfig,
+  setVltJsonOnly,
   resolveWSConfig,
+  migratableWSConfig,
   splitNegatedPatterns,
   Monorepo
 };