@vltpkg/cli-js 1.4.0 → 1.6.0

package/{chunk-HZXJ423P.js → chunk-FXD3IV2S.js}

@@ -10,14 +10,16 @@ globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
+  defaultRegistryKey,
   getTokenByURL,
   registryKeys
-} from "./chunk-OAJ3PO3Z.js";
+} from "./chunk-44AWMA4F.js";
 
 // ../../src/cli-sdk/src/query-auth.ts
 var createGetAuthHeader = (conf) => {
   const keys = registryKeys(conf.options);
-  return async (url) => getTokenByURL(url, conf.options.identity, keys);
+  const def = defaultRegistryKey(conf.options);
+  return async (url) => getTokenByURL(url, conf.options.identity, keys, def);
 };
 
 export {

package/chunk-GCTREKA4.js

@@ -0,0 +1,115 @@
+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 {
+  isInside,
+  samePath
+} from "./chunk-MCDLJZXT.js";
+import {
+  isDepID
+} from "./chunk-CAV7FKWQ.js";
+import {
+  isObject
+} from "./chunk-BF5DRGRZ.js";
+
+// ../../src/cli-sdk/src/global-state.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmod,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+var globalStateFile = (root) => resolve(root, "global-state.json");
+var readGlobalState = async (root) => {
+  let data;
+  try {
+    data = JSON.parse(await readFile(globalStateFile(root), "utf8"));
+  } catch {
+    return {};
+  }
+  if (!isObject(data)) return {};
+  const state = { ...data };
+  const { binDirs, localBinNoticed } = state;
+  if (Array.isArray(binDirs)) {
+    state.binDirs = binDirs.filter(
+      (d) => typeof d === "string" && isAbsolute(d)
+    );
+  } else delete state.binDirs;
+  if (Array.isArray(state.pendingRemove)) {
+    state.pendingRemove = state.pendingRemove.filter(
+      (d) => typeof d === "string" && isAbsolute(d)
+    );
+  } else delete state.pendingRemove;
+  if (typeof localBinNoticed !== "boolean")
+    delete state.localBinNoticed;
+  if (state.pathSetup !== "declined") delete state.pathSetup;
+  return state;
+};
+var writeFileAtomic = async (file, data, mode) => {
+  const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, data, {
+      flag: "wx",
+      ...mode === void 0 ? {} : { mode }
+    });
+    if (mode !== void 0) await chmod(tmp, mode);
+    await rename(tmp, file);
+  } catch (er) {
+    await rm(tmp, { force: true });
+    throw er;
+  }
+};
+var writeJsonAtomic = (file, data) => writeFileAtomic(file, JSON.stringify(data, null, 2) + "\n");
+var updateGlobalState = async (root, fn) => {
+  const state = fn(await readGlobalState(root));
+  await writeJsonAtomic(globalStateFile(root), state);
+  return state;
+};
+var sweepPendingRemove = async (root) => {
+  try {
+    const { pendingRemove = [] } = await readGlobalState(root);
+    if (!pendingRemove.length) return;
+    const store = resolve(await realpath(root), "node_modules/.vlt");
+    const script = process.argv[1];
+    const running = script && await realpath(script).catch(() => void 0);
+    const left = [];
+    for (const entry of pendingRemove) {
+      if (!samePath(dirname(entry), store) || !isDepID(basename(entry))) {
+        continue;
+      }
+      if (running && isInside(entry, running)) {
+        left.push(entry);
+        continue;
+      }
+      await rm(entry, { recursive: true, force: true }).catch(
+        () => left.push(entry)
+      );
+    }
+    if (left.length === pendingRemove.length) return;
+    await updateGlobalState(root, (s) => ({
+      ...s,
+      pendingRemove: left
+    }));
+  } catch {
+  }
+};
+
+export {
+  readGlobalState,
+  writeFileAtomic,
+  writeJsonAtomic,
+  updateGlobalState,
+  sweepPendingRemove
+};

package/{chunk-ZJMJ7MCT.js → chunk-GEQFMH5M.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.4.0",
+  version: "1.6.0",
   repository: {
     type: "git",
     url: "git+https://github.com/vltpkg/vltpkg.git",

package/{chunk-ISE4IRHF.js → chunk-GZVI75KX.js}

@@ -9,20 +9,20 @@ globalThis.setInterval = _vlt_setInterval;
 globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
-import {
-  asUnknownSpecPrefix
-} from "./chunk-THSYN5EK.js";
 import {
   addKey,
   asDependency
-} from "./chunk-OVPHE4O7.js";
+} from "./chunk-F5LZMLAQ.js";
+import {
+  parseSpecArg
+} from "./chunk-7M2VTFLP.js";
 import {
   joinDepIDTuple,
   splitDepID
-} from "./chunk-PLG3OYCX.js";
+} from "./chunk-CAV7FKWQ.js";
 import {
   Spec
-} from "./chunk-5IJTPZXP.js";
+} from "./chunk-6D3QAFNZ.js";
 
 // ../../src/cli-sdk/src/parse-add-remove-args.ts
 import { isAbsolute, relative, resolve } from "node:path";
@@ -68,13 +68,6 @@ var rebaseFileSpec = (spec, importerPath, scurryCwd, specOptions, monorepo) => {
   if (rebasedPath === spec.file) return spec;
   return Spec.parseArgs(rebasedPath, specOptions);
 };
-var parseArg = (item, options) => {
-  try {
-    return Spec.parseArgs(item, options);
-  } catch (er) {
-    throw asUnknownSpecPrefix(er);
-  }
-};
 var parseAddArgs = (config, scurry, monorepo) => {
   const add = new AddImportersDependenciesMapImpl();
   const items = config.positionals;
@@ -84,7 +77,7 @@ var parseAddArgs = (config, scurry, monorepo) => {
   const parsedItems = [];
   let hasFileSpecs = false;
   for (const item of items) {
-    const spec = parseArg(item, specOptions);
+    const spec = parseSpecArg(item, specOptions);
     parsedItems.push({ spec, type });
     if (spec.type === "file") hasFileSpecs = true;
     add.modifiedDependencies = true;

package/chunk-HOF7LEIC.js

@@ -0,0 +1,24 @@
+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);
+
+// ../../src/cli-sdk/src/publish-config.ts
+var getPublishConfig = (manifest) => {
+  const pc = manifest.publishConfig;
+  if (pc && typeof pc === "object") {
+    return pc;
+  }
+  return void 0;
+};
+
+export {
+  getPublishConfig
+};

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

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

package/{chunk-PHJJPY5G.js → chunk-IXAMCWIT.js}

@@ -11,13 +11,13 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   openUrl
-} from "./chunk-TPRK6IDA.js";
-import {
-  stderr
-} from "./chunk-FZUYGJZU.js";
+} from "./chunk-22LZBDEC.js";
 import {
   mermaidOutput
-} from "./chunk-OVPHE4O7.js";
+} from "./chunk-36UIE654.js";
+import {
+  stderr
+} from "./chunk-KVWGMSPW.js";
 import {
   ViewClass
 } from "./chunk-4KCU2KZL.js";

package/{chunk-ASLX43R3.js → chunk-JCNI6ZHH.js}

@@ -11,12 +11,14 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   actual,
-  callLimit,
   createVirtualRoot
-} from "./chunk-OVPHE4O7.js";
+} from "./chunk-36UIE654.js";
+import {
+  callLimit
+} from "./chunk-F5LZMLAQ.js";
 import {
   SecurityArchive
-} from "./chunk-5TNXLRW2.js";
+} from "./chunk-YTDABXPD.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -140,8 +142,8 @@ var reloadConfig = async (folder) => {
     unload("project");
   } catch {
   }
-  const { Config } = await import("./config-CSPCDMR3.js");
-  return Config.load(folder, process.argv, true);
+  const { Config } = await import("./config-EKHBW6I5.js");
+  return Config.load(folder, process.argv, true, false);
 };
 
 // ../../src/cli-sdk/src/query-host-contexts.ts

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-7T3XAYP4.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-PLG3OYCX.js";
+} from "./chunk-CAV7FKWQ.js";
 
 // ../../src/cli-sdk/src/stub-node.ts
 var createStubNode = (spec, name, version, options) => ({