@vltpkg/cli-js 1.5.0 → 1.6.1

package/{chunk-CW56EJIL.js → chunk-HT6FS4VB.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   commandAliases,
   jack
-} from "./chunk-CMLDLZZ3.js";
+} from "./chunk-EFHOWRKU.js";
 
 // ../../src/cli-sdk/src/config/usage.ts
 var toArr = (v) => Array.isArray(v) ? v : [v];

package/{chunk-VR7NRWAD.js → chunk-IHERL3TA.js}

@@ -17,19 +17,19 @@ import {
   pickManifest,
   resolve,
   revs
-} from "./chunk-IFEZ6BFV.js";
+} from "./chunk-EMTGRCSE.js";
 import {
   Monorepo,
   PackageJson
-} from "./chunk-C6ZVVEFV.js";
+} from "./chunk-KURQHX54.js";
 import {
   Spec
-} from "./chunk-LUVDMEW4.js";
+} from "./chunk-6D3QAFNZ.js";
 import {
   registryErrorMessage,
   storeRoot,
   tokenRefusalAdvice
-} from "./chunk-5KW6AOTT.js";
+} from "./chunk-4GMNWW4C.js";
 import {
   logRequest
 } from "./chunk-B6RIGNEO.js";
@@ -41,7 +41,7 @@ import {
   brotliTarballUrl,
   integrityHex,
   tarballFormat
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -338,7 +338,7 @@ var PackageInfoClient = class {
   }
   async getRegistryClient() {
     if (this.#registryClient) return this.#registryClient;
-    this.#registryClientPromise ??= import("./src-H6DFCAPH.js").then(({ RegistryClient }) => {
+    this.#registryClientPromise ??= import("./src-A5ZJNOHN.js").then(({ RegistryClient }) => {
       this.#registryClient = new RegistryClient(this.options);
       return this.#registryClient;
     });
@@ -377,7 +377,7 @@ var PackageInfoClient = class {
   }
   async getTarPool() {
     if (this.#tarPool) return this.#tarPool;
-    this.#tarPoolPromise ??= import("./src-LHDC4NJO.js").then(
+    this.#tarPoolPromise ??= import("./src-W2VQULRG.js").then(
       ({ Pool }) => {
         this.#tarPool = new Pool();
         return this.#tarPool;
@@ -426,9 +426,10 @@ var PackageInfoClient = class {
       fromLockfile = false
     } = options;
     const f = spec.final;
-    const brotli = !!resolved && tarballFormat(resolved) === "brotli";
-    const r = resolved && (integrity || brotli) ? {
-      resolved,
+    const url = f.type === "git" && f.remoteURL && resolved && !/^https?:\/\//.test(resolved) ? f.remoteURL : resolved;
+    const brotli = !!url && tarballFormat(url) === "brotli";
+    const r = url && (integrity || brotli) ? {
+      resolved: url,
       integrity,
       spec,
       ...brotli && !integrity ? { digestRequired: true } : {}
@@ -471,11 +472,10 @@ var PackageInfoClient = class {
         const storeOn = f.type === "registry" && this.#storeLinker !== "unpack";
         const copy = this.#storeLinker === "copy";
         const clone2 = this.#storeLinker === "clone";
-        const hex = !storeOn ? void 0 : r.integrity ? integrityHex(r.integrity) : integrityHex(
-          (await this.getRegistryClient()).cachedIntegrity(
-            r.resolved
-          )
-        );
+        const cachedIntegrity = storeOn && !r.integrity ? (await this.getRegistryClient()).cachedIntegrity(
+          r.resolved
+        ) : void 0;
+        const hex = !storeOn ? void 0 : r.integrity ? integrityHex(r.integrity) : integrityHex(cachedIntegrity);
         if (hex) {
           if (debug.enabled && !this.#storeHitRateLogged) {
             this.#storeHitRateLogged = true;
@@ -490,6 +490,7 @@ var PackageInfoClient = class {
             const { how, index } = linked;
             this.#storeHits[how]++;
             logRequest(r.resolved, how === "copy" ? "cache" : "store");
+            r.integrity ??= cachedIntegrity;
             return {
               ...r,
               manifest: index.manifest,
@@ -593,7 +594,7 @@ var PackageInfoClient = class {
       }
       case "remote": {
         const rc = await this.getRegistryClient();
-        const { CacheEntry: Entry, cacheKey } = await import("./src-H6DFCAPH.js");
+        const { CacheEntry: Entry, cacheKey } = await import("./src-A5ZJNOHN.js");
         const key = cacheKey("GET", new URL(r.resolved));
         const unzipped = (entry) => {
           try {

package/chunk-JV5XR5JQ.js

@@ -0,0 +1,349 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  rimraf
+} from "./chunk-PDWPFR5T.js";
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../src/rollback-remove/src/index.ts
+import { spawn } from "node:child_process";
+import { rename } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+
+// ../../src/rollback-remove/src/remove.ts
+import { resolve } from "node:path";
+var __CODE_SPLIT_SCRIPT_NAME = resolve(import.meta.dirname, "rollback-remove-src-remove.js");
+
+// ../../src/rollback-remove/src/index.ts
+var isDeno = globalThis.Deno != void 0;
+var RollbackRemove = class {
+  #key = String(Math.random()).substring(2);
+  #paths = /* @__PURE__ */ new Map();
+  async rm(path) {
+    if (this.#paths.has(path)) return;
+    const target = `${dirname(path)}/.VLT.DELETE.${this.#key}.${basename(path)}`;
+    try {
+      await rename(path, target);
+    } catch (e) {
+      if (e instanceof Error && "code" in e && /* c8 ignore start - very spurious weirdness on Windows */
+      (e.code === "ENOENT" || e.code === "EPERM")) {
+        return;
+      }
+      throw e;
+    }
+    this.#paths.set(path, target);
+  }
+  confirm() {
+    if (!this.#paths.size) return;
+    const env = { ...process.env };
+    const args = [];
+    const detached = !(isDeno && process.platform === "win32");
+    if (isDeno) {
+      args.push(
+        "--unstable-node-globals",
+        "--unstable-bare-node-builtins"
+      );
+    }
+    args.push(__CODE_SPLIT_SCRIPT_NAME);
+    const child = spawn(process.execPath, args, {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached,
+      env
+    });
+    for (const path of this.#paths.values()) {
+      child.stdin.write(`${path}\0`);
+    }
+    child.stdin.end();
+    if (detached) {
+      child.unref();
+    }
+    this.#paths.clear();
+  }
+  async rollback() {
+    const promises = [];
+    for (const [original, moved] of this.#paths) {
+      promises.push(
+        rimraf(original).catch(() => {
+        }).then(() => rename(moved, original))
+      );
+    }
+    await Promise.all(promises);
+    this.#paths.clear();
+  }
+};
+
+// ../../src/cmd-shim/src/read.ts
+import { lstat, readFile, readlink } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+
+// ../../src/cmd-shim/src/paths.ts
+var paths = process.platform === "win32" ? (path) => [
+  path + ".cmd",
+  path + ".ps1",
+  path,
+  path + ".pwsh"
+] : (path) => [path];
+
+// ../../src/cmd-shim/src/read.ts
+var extractPath = (path, cmdshimContents) => {
+  if (/\.cmd$/i.test(path)) {
+    return extractPathFromCmd(cmdshimContents);
+  } else if (/\.(ps1|pwsh)$/i.test(path)) {
+    return extractPathFromPowershell(cmdshimContents);
+  } else {
+    return extractPathFromCygwin(cmdshimContents);
+  }
+};
+var extractPathFromPowershell = (cmdshimContents) => {
+  const matches = /"(?:[$]basedir\/|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+[$]args/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var extractPathFromCmd = (cmdshimContents) => {
+  const matches = /"(?:%(?:~dp0|dp0%)\\|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+%[*]/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var extractPathFromCygwin = (cmdshimContents) => {
+  const matches = /"(?:[$]basedir\/|(?=[a-zA-Z]:[\\/]))([^"]+?)"\s+"[$]@"/.exec(
+    cmdshimContents
+  );
+  return matches?.[1]?.replace(/\\/g, "/");
+};
+var findCmdShimIfExists = async (path) => {
+  path = path.replace(/\.(cmd|pwsh|ps1)$/i, "");
+  for (const p of paths(path)) {
+    const result = await readCmdShimIfExists(p);
+    if (result) return [p, result];
+  }
+};
+var readCmdShimIfExists = async (path) => {
+  try {
+    const st = await lstat(path);
+    if (st.isSymbolicLink()) {
+      return resolve2(dirname2(path), await readlink(path));
+    }
+    const contents = await readFile(path);
+    const destination = extractPath(path, contents.toString());
+    if (destination) return resolve2(dirname2(path), destination);
+  } catch {
+  }
+};
+
+// ../../src/cmd-shim/src/index.ts
+import {
+  chmod,
+  mkdir,
+  readFile as readFile2,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname as dirname3, isAbsolute, relative } from "node:path";
+
+// ../../src/cmd-shim/src/to-batch-syntax.ts
+var convertToSetCommand = (key, value) => convertToSetCommand_(key.trim(), value.trim());
+var convertToSetCommand_ = (key, value) => key && value ? `@SET ${key}=${replaceDollarWithPercentPair(value)}\r
+` : "";
+var extractVariableValuePairs = (declarations) => declarations.reduce(
+  (pairs, declaration) => {
+    const [key = "", val = ""] = declaration.split("=");
+    pairs[key] = val;
+    return pairs;
+  },
+  {}
+);
+var convertToSetCommands = (variableString) => Object.entries(extractVariableValuePairs(variableString.split(" "))).map(([key, val]) => convertToSetCommand(key, val)).join("");
+var replaceDollarWithPercentPair = (value) => {
+  const dollarExpressions = /\$\{?([^$@#?\- \t{}:]+)\}?/g;
+  let result = "";
+  let startIndex = 0;
+  do {
+    const match = dollarExpressions.exec(value);
+    if (match) {
+      const betweenMatches = value.substring(startIndex, match.index) || "";
+      result += betweenMatches + "%" + String(match[1]) + "%";
+      startIndex = dollarExpressions.lastIndex;
+    }
+  } while (dollarExpressions.lastIndex > 0);
+  result += value.slice(startIndex);
+  return result;
+};
+
+// ../../src/cmd-shim/src/index.ts
+var shebangExpr = /^#!\s*(?:\/usr\/bin\/env\s+(?:-S\s+)?((?:[^ \t=]+=[^ \t=]+\s+)*))?([^ \t]+)(.*)$/;
+var cmdShimIfExists = async (from, to, remover) => {
+  try {
+    await stat(from);
+  } catch {
+    return;
+  }
+  await writeShim(from, to, remover);
+};
+var cmdShim = async (from, to, remover) => {
+  try {
+    await stat(from);
+    await writeShim(from, to, remover);
+  } catch (er) {
+    throw error("Could not shim to executable file", {
+      path: from,
+      target: to,
+      cause: er
+    });
+  }
+};
+var writeShim = async (from, to, remover) => {
+  await Promise.all([
+    remover.rm(to),
+    remover.rm(to + ".cmd"),
+    remover.rm(to + ".ps1"),
+    remover.rm(to + ".pwsh")
+  ]);
+  await mkdir(dirname3(to), { recursive: true });
+  const data = await readFile2(from, "utf8").catch(() => "");
+  if (!data) {
+    return await writeShim_(from, to);
+  }
+  const firstLine = data.trim().split(/\r*\n/)[0];
+  const shebang = firstLine?.match(shebangExpr) ?? void 0;
+  return writeShim_(
+    from,
+    to,
+    shebang?.[2],
+    shebang?.[3],
+    shebang?.[1]
+  );
+};
+var writeShim_ = async (from, to, prog, args, variables) => {
+  let shTarget = relative(dirname3(to), from);
+  const [dp0, basedir] = isAbsolute(shTarget) ? ["", ""] : ["%dp0%\\", "$basedir/"];
+  let target = shTarget.split("/").join("\\");
+  let longProg;
+  let shProg = prog?.split("\\").join("/");
+  let shLongProg;
+  let pwshProg = shProg && `"${shProg}$exe"`;
+  let pwshLongProg;
+  shTarget = shTarget.split("\\").join("/");
+  args = args || "";
+  variables = variables || "";
+  if (!prog) {
+    prog = `"${dp0}${target}"`;
+    shProg = `"${basedir}${shTarget}"`;
+    pwshProg = shProg;
+    args = "";
+    target = "";
+    shTarget = "";
+  } else {
+    longProg = `"%dp0%\\${prog}.exe"`;
+    shLongProg = `"$basedir/${prog}"`;
+    pwshLongProg = `"$basedir/${prog}$exe"`;
+    target = `"${dp0}${target}"`;
+    shTarget = `"${basedir}${shTarget}"`;
+  }
+  const head = "@ECHO off\r\nGOTO start\r\n:find_dp0\r\nSET dp0=%~dp0\r\nEXIT /b\r\n:start\r\nSETLOCAL\r\nCALL :find_dp0\r\n";
+  let cmd;
+  if (longProg) {
+    shLongProg = (shLongProg ?? "").trim();
+    args = args.trim();
+    const variablesBatch = convertToSetCommands(variables);
+    cmd = `${head}${variablesBatch}\r
+IF EXIST ${longProg} (\r
+  SET "_prog=${longProg.replace(/(^")|("$)/g, "")}"\r
+) ELSE (\r
+  SET "_prog=${prog.replace(/(^")|("$)/g, "")}"\r
+  SET PATHEXT=%PATHEXT:;.JS;=;%\r
+)\r
+\r
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" ${args} ${target} %*\r
+`;
+  } else {
+    cmd = `${head}${prog} ${args} ${target} %*\r
+`;
+  }
+  let sh = `#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')")
+
+case \`uname\` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=\`cygpath -w "$basedir"\`
+        fi
+    ;;
+esac
+
+`;
+  if (shLongProg) {
+    sh += `if [ -x ${shLongProg} ]; then
+  exec ${variables}${shLongProg} ${args} ${shTarget} "$@"
+else 
+  exec ${variables}${shProg} ${args} ${shTarget} "$@"
+fi
+`;
+  } else {
+    sh += `exec ${shProg} ${args} ${shTarget} "$@"
+`;
+  }
+  let pwsh = '#!/usr/bin/env pwsh\n$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent\n\n$exe=""\nif ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {\n  # Fix case when both the Windows and Linux builds of Node\n  # are installed in the same directory\n  $exe=".exe"\n}\n';
+  if (shLongProg) {
+    pwsh += `$ret=0
+if (Test-Path ${pwshLongProg}) {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshLongProg} ${args} ${shTarget} $args
+  } else {
+    & ${pwshLongProg} ${args} ${shTarget} $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & ${pwshProg} ${args} ${shTarget} $args
+  } else {
+    & ${pwshProg} ${args} ${shTarget} $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret
+`;
+  } else {
+    pwsh += `# Support pipeline input
+if ($MyInvocation.ExpectingInput) {
+  $input | & ${pwshProg} ${args} ${shTarget} $args
+} else {
+  & ${pwshProg} ${args} ${shTarget} $args
+}
+exit $LASTEXITCODE
+`;
+  }
+  await Promise.all([
+    writeFile(to + ".cmd", cmd, "utf8"),
+    writeFile(to + ".ps1", pwsh, "utf8"),
+    writeFile(to, sh, "utf8")
+  ]);
+  await chmodShim(to);
+};
+var chmodShim = async (to) => await Promise.all([
+  chmod(to, 493),
+  chmod(to + ".cmd", 493),
+  chmod(to + ".ps1", 493)
+]);
+
+export {
+  findCmdShimIfExists,
+  readCmdShimIfExists,
+  cmdShimIfExists,
+  cmdShim,
+  RollbackRemove
+};

package/{chunk-T5EP7QEF.js → chunk-JZXNHIQE.js}

@@ -15,10 +15,10 @@ import {
 } from "./chunk-SRWDPPLX.js";
 import {
   minimatch
-} from "./chunk-C6ZVVEFV.js";
+} from "./chunk-KURQHX54.js";
 import {
   Spec
-} from "./chunk-LUVDMEW4.js";
+} from "./chunk-6D3QAFNZ.js";
 import {
   parse,
   stringify
@@ -1865,7 +1865,12 @@ var require_ignore = __commonJS({
 // ../../src/cli-sdk/src/pack-tarball.ts
 var ssri = __toESM(require_lib(), 1);
 import assert from "node:assert";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync
+} from "node:fs";
 import { join } from "node:path";
 var import_ignore = __toESM(require_ignore(), 1);
 var replaceWorkspaceAndCatalogSpecs = (manifest_, config) => {
@@ -2004,7 +2009,16 @@ var buildPackFilter = (manifest, packDir) => {
       }
     }
   }
-  return (path) => {
+  const files = (manifestWithFiles.files ?? []).map((pattern) => pattern.replace(/^\.?\//, "").replace(/\/+$/, "")).filter(Boolean);
+  const isReadableDir = (dir) => {
+    try {
+      readdirSync(join(packDir, dir));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return (path, entry) => {
     const normalizedPath = path.replace(/^\.\//, "");
     if (path === "." || normalizedPath === "") {
       return true;
@@ -2025,30 +2039,16 @@ var buildPackFilter = (manifest, packDir) => {
     if (hasEmptyFilesField) {
       return false;
     }
-    if (hasFilesField && manifestWithFiles.files) {
-      return manifestWithFiles.files.some((pattern) => {
-        if (pattern.endsWith("/")) {
-          const dirName = pattern.slice(0, -1);
-          const globPattern = pattern.replace(/\/$/, "/**");
-          const matchesDir = normalizedPath === dirName;
-          const matchesContents = minimatch(
-            normalizedPath,
-            globPattern,
-            { dot: true }
-          );
-          return matchesDir || matchesContents;
-        }
-        const directMatch = minimatch(normalizedPath, pattern, {
-          dot: true
-        });
-        const isParentDir = pattern.includes("/") && pattern.startsWith(normalizedPath + "/");
-        const isChildOfPattern = minimatch(
-          normalizedPath,
-          pattern + "/**",
-          { dot: true }
-        );
-        return directMatch || isParentDir || isChildOfPattern;
-      });
+    if (hasFilesField) {
+      const isDir = "isDirectory" in entry && entry.isDirectory();
+      return files.some(
+        (pattern) => minimatch(normalizedPath, pattern, { dot: true }) || minimatch(normalizedPath, `${pattern}/**`, { dot: true })
+      ) || isDir && files.some(
+        (pattern) => minimatch(normalizedPath, pattern, {
+          dot: true,
+          partial: true
+        })
+      ) && isReadableDir(normalizedPath);
     }
     if (ig?.ignores(normalizedPath)) {
       return false;

package/{chunk-IJUVVD7E.js → chunk-KD5ZK72K.js}

@@ -11,7 +11,7 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   getId
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 
 // ../../src/cli-sdk/src/stub-node.ts
 var createStubNode = (spec, name, version, options) => ({

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

@@ -13,7 +13,7 @@ import {
   graphRun,
   graphRunSync,
   joinDepIDTuple
-} from "./chunk-F7NPYSI2.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   load,
   parse,
@@ -33,7 +33,7 @@ import {
   normalizeManifest,
   parseRange,
   satisfies
-} from "./chunk-6LZM3I4Q.js";
+} from "./chunk-BF5DRGRZ.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -115,6 +115,7 @@ var PackageJson = class {
       writeFileSync(filename, stringify(manifest, void 0, indent));
       this.#cache.set(dir, manifest);
       this.#pathCache.set(manifest, dir);
+      this.#errCache.delete(dir);
     } catch (err) {
       this.#cache.delete(dir);
       this.#pathCache.delete(manifest);
@@ -5350,5 +5351,6 @@ export {
   resolveWSConfig,
   migratableWSConfig,
   splitNegatedPatterns,
-  Monorepo
+  Monorepo,
+  workspaceCache
 };

package/{chunk-GUP55DM6.js → chunk-L3ZF7OYM.js}

@@ -11,11 +11,11 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   stderr
-} from "./chunk-WHWPAYZY.js";
+} from "./chunk-MSWOR3FV.js";
 import {
   migratableWSConfig,
   resolveWSConfig
-} from "./chunk-C6ZVVEFV.js";
+} from "./chunk-KURQHX54.js";
 import {
   save
 } from "./chunk-HTOTG4TS.js";

package/{chunk-X6JKMIOU.js → chunk-LGQVZTYR.js}

@@ -12,43 +12,12 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   source_default
 } from "./chunk-WGDTG44V.js";
+import {
+  loadPackageJson
+} from "./chunk-E74WGW5C.js";
 import {
   commandAliases
-} from "./chunk-CMLDLZZ3.js";
-
-// ../../node_modules/.vlt/~npm~package-json-from-dist@1.0.1/node_modules/package-json-from-dist/dist/esm/index.js
-import { readFileSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-var NM = `${sep}node_modules${sep}`;
-var STORE = `.store${sep}`;
-var PKG = `${sep}package${sep}`;
-var DIST = `${sep}dist${sep}`;
-var findPackageJson = (from, pathFromSrc = "../package.json") => {
-  const f = typeof from === "object" || from.startsWith("file://") ? fileURLToPath(from) : from;
-  const __dirname = dirname(f);
-  const nms = __dirname.lastIndexOf(NM);
-  if (nms !== -1) {
-    const nm = __dirname.substring(0, nms + NM.length);
-    const pkgDir = __dirname.substring(nms + NM.length);
-    if (pkgDir.startsWith(STORE)) {
-      const pkg = pkgDir.indexOf(PKG, STORE.length);
-      if (pkg) {
-        return resolve(nm, pkgDir.substring(0, pkg + PKG.length), "package.json");
-      }
-    }
-    const pkgName = pkgDir.startsWith("@") ? pkgDir.split(sep, 2).join(sep) : String(pkgDir.split(sep)[0]);
-    return resolve(nm, pkgName, "package.json");
-  } else {
-    const d = __dirname.lastIndexOf(DIST);
-    if (d !== -1) {
-      return resolve(__dirname.substring(0, d), "package.json");
-    } else {
-      return resolve(__dirname, pathFromSrc);
-    }
-  }
-};
-var loadPackageJson = (from, pathFromSrc = "../package.json") => JSON.parse(readFileSync(findPackageJson(from, pathFromSrc), "utf8"));
+} from "./chunk-EFHOWRKU.js";
 
 // ../../src/cli-sdk/src/custom-help.ts
 var { version } = loadPackageJson(
@@ -407,7 +376,6 @@ ${s("dim", `Run \`vlt help <command>\` for detailed information about a specific
 };
 
 export {
-  loadPackageJson,
   generateDefaultHelp,
   generateFullHelp
 };

package/{chunk-G3FZ2ZJK.js → chunk-M242QVJS.js}

@@ -14,7 +14,7 @@ var require = _vlt_createRequire(import.meta.filename);
 var package_default = {
   name: "@vltpkg/user-agent",
   description: "The User-Agent string that vlt sends with every outbound request",
-  version: "1.5.0",
+  version: "1.6.1",
   repository: {
     type: "git",
     url: "git+https://github.com/vltpkg/vltpkg.git",