@vltpkg/cli-js 1.4.0 → 1.5.0

package/skills-YD2TB2VD.js

@@ -0,0 +1,495 @@
+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 {
+  filterNodesByQueryParts,
+  load2 as load,
+  lstat,
+  mountSkill,
+  norm,
+  packageKey,
+  readMounts,
+  realOr,
+  samePath,
+  skillsDirs,
+  unmountSkill,
+  unshare
+} from "./chunk-2U4PVHP4.js";
+import "./chunk-SMXXFQPI.js";
+import "./chunk-C6ZVVEFV.js";
+import {
+  splitDepID
+} from "./chunk-F7NPYSI2.js";
+import "./chunk-LUVDMEW4.js";
+import "./chunk-HTOTG4TS.js";
+import "./chunk-G3FZ2ZJK.js";
+import "./chunk-B6RIGNEO.js";
+import "./chunk-XNLSTHDK.js";
+import "./chunk-Y5PA7DVK.js";
+import {
+  parse
+} from "./chunk-6LZM3I4Q.js";
+import "./chunk-WZWDS3W4.js";
+import "./chunk-PZLD7RTK.js";
+
+// ../../src/graph/src/skills/index.ts
+import { existsSync } from "node:fs";
+
+// ../../src/graph/src/skills/discover.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var skillDirName = /^[a-z0-9][a-z0-9._-]*$/i;
+var specName = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var topKey = /^([A-Za-z0-9_-]+):/;
+var blockIndicator = /^[>|][-+1-9]*$/;
+var fold = (inline, more) => {
+  let value = [blockIndicator.test(inline) ? "" : inline, ...more].filter(Boolean).join(" ");
+  const q = value[0];
+  if (value.length > 1 && (q === '"' || q === "'") && value.endsWith(q)) {
+    value = value.slice(1, -1).trim();
+  }
+  return value || void 0;
+};
+var readFrontmatter = (file) => {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return {};
+  }
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const end = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (end === -1) return {};
+  const fm = {};
+  let key;
+  let inline = "";
+  let more = [];
+  const flush = () => {
+    if (key) fm[key] = fold(inline, more);
+    key = void 0;
+  };
+  for (const line of lines.slice(1, end)) {
+    if (!line.trim()) continue;
+    const m = topKey.exec(line);
+    if (m) {
+      flush();
+      const k = m[1];
+      if (k === "name" || k === "description") {
+        key = k;
+        inline = line.slice(k.length + 1).trim();
+        const hash = inline.search(/(?:^|\s)#/);
+        if (hash !== -1 && !/^["']/.test(inline)) {
+          inline = inline.slice(0, hash).trim();
+        }
+        more = [];
+      }
+    } else if (/^\s/.test(line)) {
+      if (key) more.push(line.trim());
+    } else {
+      flush();
+    }
+  }
+  flush();
+  return fm;
+};
+var sanitize = (s) => {
+  const clean = s?.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
+  return clean ? clean.slice(0, 1024) : void 0;
+};
+var lc = (s) => s.toLowerCase();
+var isDir = (path) => !!lstat(path)?.isDirectory();
+var isFile = (path) => !!lstat(path)?.isFile();
+var isSkillMd = (name) => name.toLowerCase() === "skill.md";
+var shipDirs = ["skills", "dist/skills", ".agents/skills"];
+var subdir = (dir, sub) => {
+  let path = dir;
+  for (const seg of sub.split("/")) {
+    path = resolve(path, seg);
+    if (!isDir(path)) return void 0;
+  }
+  return path;
+};
+var scan = (dir, pkgName) => {
+  const found = [];
+  const has = (skill) => found.some((f) => lc(f.skill) === lc(skill));
+  const root = resolve(dir, "SKILL.md");
+  if (isFile(root)) {
+    const { name, description } = readFrontmatter(root);
+    const skill = name && name.length <= 64 && specName.test(name) ? name : pkgName.slice(pkgName.lastIndexOf("/") + 1);
+    if (skillDirName.test(skill) && !isSkillMd(skill)) {
+      found.push({ skill, path: dir, name, description });
+    }
+  }
+  for (const sub of shipDirs) {
+    const skillsDir = subdir(dir, sub);
+    if (!skillsDir) continue;
+    for (const d of readdirSync(skillsDir).sort()) {
+      if (!skillDirName.test(d) || isSkillMd(d) || has(d)) continue;
+      const path = resolve(skillsDir, d);
+      const file = resolve(path, "SKILL.md");
+      if (!isDir(path) || !isFile(file)) continue;
+      const { name, description } = readFrontmatter(file);
+      found.push({ skill: d, path, name, description });
+    }
+  }
+  return found;
+};
+var rank = (node) => {
+  let r = 2;
+  for (const { from } of node.edgesIn) {
+    if (from.mainImporter) return 0;
+    if (from.importer) r = 1;
+  }
+  return r;
+};
+var ver = (node) => node.version ? parse(node.version) : void 0;
+var byVersion = (a, b) => {
+  const va = ver(a);
+  const vb = ver(b);
+  return va && vb ? vb.compare(va) : 0;
+};
+var compare = (a, b) => rank(a) - rank(b) || byVersion(a, b) || a.id.localeCompare(b.id, "en");
+var aliasOf = (node) => {
+  const edges = [...node.edgesIn];
+  const n = (edges.find((e) => e.from.mainImporter) ?? edges.find((e) => e.from.importer))?.name;
+  return n === node.name ? void 0 : n;
+};
+var scannable = (node) => !node.importer && node.inVltStore() && splitDepID(node.id)[0] !== "file";
+var shipsSkills = (node) => scannable(node) && scan(realOr(resolve(node.projectRoot, node.location)), node.name).length > 0;
+var discoverSkills = (nodes, scurry, mounts = []) => {
+  const key = (name, path) => `${lc(name)}\0${norm(path)}`;
+  const linkedIn = /* @__PURE__ */ new Map();
+  for (const m of mounts) {
+    const k = key(m.name, realOr(m.target));
+    const dirs = linkedIn.get(k) ?? [];
+    if (!dirs.includes(m.dir.dir)) dirs.push(m.dir.dir);
+    linkedIn.set(k, dirs);
+  }
+  const scanned = /* @__PURE__ */ new Map();
+  const byPkg = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!scannable(node)) continue;
+    const found = scan(
+      realOr(node.resolvedLocation(scurry)),
+      node.name
+    );
+    scanned.set(
+      node.id,
+      found.map(({ skill, path }) => ({ skill, path }))
+    );
+    const key2 = packageKey(node.id);
+    const list = byPkg.get(key2) ?? [];
+    list.push({ node, found });
+    byPkg.set(key2, list);
+  }
+  const rows = [];
+  for (const list of byPkg.values()) {
+    const { node, found } = list.reduce(
+      (a, b) => compare(a.node, b.node) <= 0 ? a : b
+    );
+    for (const { skill, path, name, description } of found) {
+      const fm = sanitize(name);
+      rows.push([
+        {
+          name: node.name,
+          alias: aliasOf(node),
+          version: node.version,
+          id: node.id,
+          skill,
+          ...fm && lc(fm) !== lc(skill) && { frontmatterName: fm },
+          description: sanitize(description),
+          path,
+          linked: linkedIn.get(key(skill, path)) ?? []
+        },
+        rank(node)
+      ]);
+    }
+  }
+  const skills = rows.sort(
+    ([a, ra], [b, rb]) => lc(a.skill).localeCompare(lc(b.skill), "en") || ra - rb || a.id.localeCompare(b.id, "en")
+  ).map(([s]) => s);
+  return { skills, scanned };
+};
+
+// ../../src/graph/src/skills/gitignore.ts
+import { lstatSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var GITIGNORE_BEGIN = "# >>> vlt agent skills (links into node_modules)";
+var GITIGNORE_END = "# <<< vlt agent skills";
+var sorted = (names) => [...names].sort((a, b) => a.localeCompare(b, "en")).map((n) => `/${n}`);
+var update = (file, { add, remove }) => {
+  const st = lstatSync(file, { throwIfNoEntry: false });
+  if (st && !st.isFile()) return "refused";
+  const text = st ? readFileSync2(file, "utf8") : "";
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines = text.split(eol);
+  const begin = lines.findIndex((l) => l.trim() === GITIGNORE_BEGIN);
+  const end = lines.findIndex(
+    (l, i) => begin !== -1 && i > begin && l.trim() === GITIGNORE_END
+  );
+  let out;
+  if (end === -1) {
+    if (!add.length) return "ok";
+    out = (text && !text.endsWith(eol) ? text + eol : text) + [GITIGNORE_BEGIN, ...sorted(add), GITIGNORE_END].join(eol) + eol;
+  } else {
+    const rm = new Set(sorted(remove));
+    const block = lines.slice(begin + 1, end).filter((l) => !rm.has(l.trim()));
+    const have = new Set(block.map((l) => l.trim()));
+    lines.splice(
+      begin + 1,
+      end - begin - 1,
+      ...block,
+      ...sorted(add).filter((l) => !have.has(l))
+    );
+    out = lines.join(eol);
+  }
+  if (out !== text) writeFileSync(file, out);
+  return "ok";
+};
+var editGitignore = (dir, edit) => {
+  try {
+    return update(join(dir, ".gitignore"), edit);
+  } catch {
+    return "refused";
+  }
+};
+
+// ../../src/graph/src/skills/mask.ts
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var globRegExp = (pattern) => new RegExp(`^${pattern.split("*").map(escape).join(".*")}$`, "i");
+var matches = (re, s) => re.test(s.skill) || !!s.frontmatterName && re.test(s.frontmatterName);
+var maskSkills = (skills, parts) => {
+  const compiled = parts.map((p) => ({
+    keys: new Set([...p.ids].map(packageKey)),
+    patterns: p.patterns?.map((pattern) => ({
+      pattern,
+      re: globRegExp(pattern)
+    }))
+  }));
+  const picked = skills.filter(
+    (s) => compiled.some(
+      (p) => p.keys.has(packageKey(s.id)) && (!p.patterns || p.patterns.some(({ re }) => matches(re, s)))
+    )
+  );
+  const unmatched = [];
+  for (const p of compiled) {
+    if (!p.patterns) continue;
+    const own = skills.filter((s) => p.keys.has(packageKey(s.id)));
+    for (const { pattern, re } of p.patterns) {
+      if (own.some((s) => matches(re, s))) continue;
+      unmatched.push({
+        pattern,
+        ...p.keys.size > 0 && {
+          skills: [...new Set(own.map((s) => s.skill))].sort(
+            (a, b) => a.localeCompare(b, "en")
+          )
+        }
+      });
+    }
+  }
+  return { skills: picked, unmatched };
+};
+
+// ../../src/graph/src/skills/index.ts
+var lc2 = (s) => s.toLowerCase();
+var selectNodes = async (o) => {
+  const graph = o.graph ?? load({ ...o, loadManifests: true });
+  const { ids, parts, unscanned } = await filterNodesByQueryParts(
+    graph,
+    o.target ?? "*"
+  );
+  const nodes = [...graph.nodes.values()].filter((n) => ids.has(n.id));
+  return { graph, nodes, parts, unscanned };
+};
+var dirsOf = (o, create = false) => skillsDirs({
+  projectRoot: o.projectRoot,
+  configured: o.skillsDirs,
+  env: o.env,
+  create
+});
+var liveOwners = (mounts) => mounts.flatMap(
+  (m) => m.owner && existsSync(m.target) ? [m.owner] : []
+);
+var unshareSkills = async (graph, ids, scurry) => {
+  for (const id of new Set(ids)) {
+    const node = graph.nodes.get(id);
+    if (node?.inVltStore())
+      await unshare(node.resolvedLocation(scurry));
+  }
+};
+var label = (s) => {
+  const pkg = s.version ? `${s.name}@${s.version}` : s.name;
+  return s.alias ? `${s.alias} (${pkg})` : pkg;
+};
+var pick = (found, parts, unscanned) => {
+  const { skills: masked, unmatched } = maskSkills(found, parts);
+  const ok = (s) => !unscanned?.ids.has(s.id);
+  const picked = masked.filter(ok);
+  const names = new Set(picked.map((s) => lc2(s.skill)));
+  const dropped = masked.filter(
+    (s) => !ok(s) && !names.has(lc2(s.skill))
+  );
+  return { skills: found.filter(ok), picked, unmatched, dropped };
+};
+var report = (dropped, unscanned) => unscanned && dropped.length ? {
+  unscanned: dropped.map((s) => `${s.skill} (${label(s)})`),
+  unscannedReason: unscanned.reason
+} : {};
+var listSkills = async (o) => {
+  const { graph, nodes, parts, unscanned } = await selectNodes(o);
+  const { targets, scan: scan2, skipped } = dirsOf(o);
+  const { skills } = discoverSkills(nodes, o.scurry, readMounts(scan2));
+  const { picked, dropped } = pick(skills, parts, unscanned);
+  return {
+    project: graph.mainImporter.name,
+    graph,
+    skills: picked,
+    dirs: targets.map((d) => d.dir),
+    ...skipped.length ? { skipped } : null,
+    ...report(dropped, unscanned)
+  };
+};
+var linkSkills = async (o) => {
+  const { graph, nodes, parts, unscanned } = await selectNodes(o);
+  const { skills: found, scanned } = discoverSkills(nodes, o.scurry);
+  const { skills, picked, unmatched, dropped } = pick(
+    found,
+    parts,
+    unscanned
+  );
+  const inMask = new Set(picked);
+  const { targets, scan: scan2, skipped } = dirsOf(o, picked.length > 0);
+  const res = {
+    linked: [],
+    unchanged: [],
+    removed: [],
+    conflicts: [],
+    dirs: targets.map((d) => d.dir)
+  };
+  const mounts = readMounts(scan2);
+  const byName = new Map(
+    mounts.map((m) => [`${m.dir.dir}\0${lc2(m.name)}`, m])
+  );
+  const stale = (m) => !m.owner || !graph.nodes.has(m.owner) || !existsSync(m.target) || scanned.get(m.owner)?.some(
+    (f) => lc2(f.skill) === lc2(m.name) && samePath(f.path, m.target)
+  ) === false;
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of skills) {
+    const k = lc2(s.skill);
+    groups.set(k, [...groups.get(k) ?? [], s]);
+  }
+  const at = (dir, k, group) => {
+    const m = byName.get(`${dir.dir}\0${k}`);
+    const key = m?.owner && packageKey(m.owner);
+    return { m, own: group.find((s) => packageKey(s.id) === key) };
+  };
+  const cands = (group) => group.filter((s) => inMask.has(s));
+  const first = new Map(
+    [...groups].map(([k, group]) => {
+      const c = cands(group);
+      return [
+        k,
+        targets.map((d) => at(d, k, c).own).find((s) => !!s) ?? c[0]
+      ];
+    })
+  );
+  const isTarget = new Set(targets);
+  const picks = [];
+  for (const dir of scan2) {
+    for (const [k, group] of groups) {
+      const { m, own } = at(dir, k, group);
+      if (isTarget.has(dir)) {
+        const winner = o.apply ? first.get(k) : own ?? (m && !stale(m) ? void 0 : first.get(k));
+        picks.push({
+          dir,
+          winner,
+          losers: cands(group).filter((s) => s !== winner),
+          m
+        });
+      } else if (own && !o.apply) {
+        picks.push({ dir, winner: own, losers: [], m });
+      }
+    }
+  }
+  await unshareSkills(
+    graph,
+    [
+      ...picks.flatMap(({ winner }) => winner ? [winner.id] : []),
+      ...liveOwners(mounts)
+    ],
+    o.scurry
+  );
+  const gone = [];
+  const foreign = [];
+  const kept = /* @__PURE__ */ new Set();
+  const where = /* @__PURE__ */ new Map();
+  for (const { dir, winner, losers, m } of picks) {
+    if (winner) {
+      if (m && m.name !== winner.skill) {
+        unmountSkill(m);
+        gone.push(m);
+      }
+      const mount = `${dir.dir}/${winner.skill}`;
+      const r = mountSkill(winner, dir);
+      if (r === "conflict") {
+        res.conflicts.push(mount);
+        foreign.push({ dir, name: winner.skill });
+      } else {
+        const k = `${winner.id}\0${winner.skill}`;
+        const linked = where.get(k) ?? [];
+        linked.push(dir.dir);
+        where.set(k, linked);
+        res[r].push({ ...winner, linked, dir: dir.dir, mount });
+        kept.add(mount);
+      }
+    }
+    for (const s of losers)
+      res.conflicts.push(`${dir.dir}/${s.skill} (${label(s)})`);
+  }
+  const after = readMounts(scan2);
+  const present = [];
+  for (const m of after) {
+    if (o.apply ? kept.has(m.mount) : !stale(m)) {
+      present.push(m);
+      continue;
+    }
+    unmountSkill(m);
+    gone.push(m);
+    res.removed.push(m.mount);
+  }
+  const gitignore = [];
+  for (const dir of scan2) {
+    const add = present.filter((m) => m.dir === dir).map((m) => m.name);
+    const remove = [...gone, ...foreign].filter((m) => m.dir === dir && !add.includes(m.name)).map((m) => m.name);
+    if ((add.length || remove.length) && editGitignore(dir.real, { add, remove }) === "refused") {
+      gitignore.push(`${dir.dir}/.gitignore`);
+    }
+  }
+  if (skipped.length) res.skipped = skipped;
+  if (gitignore.length) res.gitignore = gitignore;
+  if (unmatched.length) res.unmatched = unmatched;
+  const left = dropped.filter(
+    (s) => !targets.every(
+      (d) => present.some(
+        (m) => m.dir === d && m.owner === s.id && lc2(m.name) === lc2(s.skill)
+      )
+    )
+  );
+  return Object.assign(res, report(left, unscanned));
+};
+export {
+  discoverSkills,
+  linkSkills,
+  listSkills,
+  readFrontmatter,
+  shipsSkills
+};

package/{src-4CYCUWZL.js → src-34D4DOOH.js}

@@ -11,44 +11,47 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   loadCommand
-} from "./chunk-T6FBP4OU.js";
+} from "./chunk-T2VBCUF5.js";
 import {
   flushAndExit,
   indent,
   outputCommand,
   stderr,
   stdout
-} from "./chunk-FZUYGJZU.js";
+} from "./chunk-WHWPAYZY.js";
 import {
   loadPackageJson
-} from "./chunk-QCSUWACA.js";
-import "./chunk-G2YT2GWF.js";
+} from "./chunk-X6JKMIOU.js";
 import {
   asRootError,
   findRootError
-} from "./chunk-5Y4SYLJ2.js";
+} from "./chunk-4TSHLSRK.js";
 import {
   Config
-} from "./chunk-5RHABCYI.js";
-import "./chunk-TO23PR7J.js";
+} from "./chunk-XCQCYB6G.js";
+import "./chunk-VR7NRWAD.js";
 import "./chunk-SRWDPPLX.js";
-import "./chunk-WGDTG44V.js";
-import "./chunk-THSYN5EK.js";
-import "./chunk-I7UMHYZX.js";
+import "./chunk-IFEZ6BFV.js";
+import {
+  setVltJsonOnly
+} from "./chunk-C6ZVVEFV.js";
 import "./chunk-4KCU2KZL.js";
-import "./chunk-PLG3OYCX.js";
-import "./chunk-5IJTPZXP.js";
+import "./chunk-WGDTG44V.js";
+import "./chunk-UZ6ICZE3.js";
 import {
   getSortedCliOptions,
   getSortedKeys
-} from "./chunk-WF6KLKRN.js";
+} from "./chunk-CMLDLZZ3.js";
+import "./chunk-F7NPYSI2.js";
+import "./chunk-LUVDMEW4.js";
 import "./chunk-HTOTG4TS.js";
-import "./chunk-SR2VOY5J.js";
-import "./chunk-U7TEQCBN.js";
+import "./chunk-5KW6AOTT.js";
+import "./chunk-SUU2WETN.js";
+import "./chunk-B6RIGNEO.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-6IF3RJND.js";
 import "./chunk-Y5PA7DVK.js";
-import "./chunk-FLH4YC6W.js";
+import "./chunk-6LZM3I4Q.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 
@@ -100,6 +103,7 @@ var run = async () => {
   if (vlt.get("version")) {
     return stdout(version);
   }
+  setVltJsonOnly(vlt.command === "ci");
   const { monorepo } = vlt.options;
   if (vlt.get("workspace") === void 0) {
     const ws = monorepo?.get(cwd);
@@ -109,8 +113,9 @@ var run = async () => {
     }
   }
   if (vlt.command !== "init" && (vlt.get("workspace") || vlt.get("workspace-group")) && ![...monorepo?.values() ?? []].length) {
+    const where = vlt.command === "ci" ? "the vlt.json config (vlt ci ignores package.json and pnpm-workspace.yaml)" : 'the vlt.json config, the "workspaces" field of the root package.json, or the "packages" list of pnpm-workspace.yaml';
     stderr(
-      `Error: No matching workspaces found. Make sure the vlt.json config, the "workspaces" field of the root package.json, or the "packages" list of pnpm-workspace.yaml contains the correct workspaces.`
+      `Error: No matching workspaces found. Make sure ${where} contains the correct workspaces.`
     );
     if (vlt.get("workspace")) {
       stderr(indent(`Workspace: ${format(vlt.get("workspace"))}`));
@@ -125,7 +130,7 @@ var run = async () => {
     return flushAndExit(process.exitCode || 1);
   }
   if (vlt.command === "registry") {
-    const { dispatchRegistry } = await import("./registry-W7BRZZZ2.js");
+    const { dispatchRegistry } = await import("./registry-6HKQYSZX.js");
     await dispatchRegistry(vlt);
   }
   const command = await loadCommand(vlt.command);

package/{src-I3GMULFP.js → src-H6DFCAPH.js}

@@ -28,22 +28,23 @@ import {
   runtimeTokens,
   setRuntimeToken,
   setToken
-} from "./chunk-OAJ3PO3Z.js";
-import "./chunk-APMYKJI2.js";
+} from "./chunk-35EG6T3J.js";
+import "./chunk-QNHBAGXQ.js";
+import {
+  userAgent
+} from "./chunk-G3FZ2ZJK.js";
 import {
   assertOk,
   registryErrorMessage,
   requestError,
   storeRoot
-} from "./chunk-SR2VOY5J.js";
-import {
-  userAgent
-} from "./chunk-ZJMJ7MCT.js";
-import "./chunk-U7TEQCBN.js";
+} from "./chunk-5KW6AOTT.js";
+import "./chunk-SUU2WETN.js";
+import "./chunk-B6RIGNEO.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";
 import "./chunk-Y5PA7DVK.js";
-import "./chunk-FLH4YC6W.js";
+import "./chunk-6LZM3I4Q.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 export {

package/{src-LUTN2ODD.js → src-LHDC4NJO.js}

@@ -28,7 +28,7 @@ import {
   unpackSync,
   unpackToStoreSync,
   verifyStoreEntry
-} from "./chunk-DNRR3XMG.js";
+} from "./chunk-ISAMD2FE.js";
 import {
   cloneAvailable,
   cloneDir
@@ -37,7 +37,7 @@ import {
   rimrafSync
 } from "./chunk-PDWPFR5T.js";
 import "./chunk-Y5PA7DVK.js";
-import "./chunk-FLH4YC6W.js";
+import "./chunk-6LZM3I4Q.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";
 

package/{token-OANOBE3G.js → token-OF63PFTQ.js}

@@ -9,14 +9,14 @@ globalThis.setInterval = _vlt_setInterval;
 globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
-import {
-  requireRegistry
-} from "./chunk-THSYN5EK.js";
 import {
   commandUsage
-} from "./chunk-LHPEBLOU.js";
-import "./chunk-5IJTPZXP.js";
-import "./chunk-WF6KLKRN.js";
+} from "./chunk-CW56EJIL.js";
+import {
+  requireRegistry
+} from "./chunk-UZ6ICZE3.js";
+import "./chunk-CMLDLZZ3.js";
+import "./chunk-LUVDMEW4.js";
 import {
   RegistryClient,
   deleteToken,
@@ -25,15 +25,16 @@ import {
   normalizeRegistryKey,
   registryBase,
   setToken
-} from "./chunk-OAJ3PO3Z.js";
-import "./chunk-APMYKJI2.js";
-import "./chunk-SR2VOY5J.js";
-import "./chunk-ZJMJ7MCT.js";
-import "./chunk-U7TEQCBN.js";
+} from "./chunk-35EG6T3J.js";
+import "./chunk-QNHBAGXQ.js";
+import "./chunk-G3FZ2ZJK.js";
+import "./chunk-5KW6AOTT.js";
+import "./chunk-SUU2WETN.js";
+import "./chunk-B6RIGNEO.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";
 import "./chunk-Y5PA7DVK.js";
-import "./chunk-FLH4YC6W.js";
+import "./chunk-6LZM3I4Q.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";