@vltpkg/cli-js 1.3.4 → 1.3.5

package/{access-AY2CIGVN.js → access-X2ZZH2BV.js}

@@ -19,12 +19,12 @@ import "./chunk-64VFL4WI.js";
 import "./chunk-XU5WNX4S.js";
 import {
   RegistryClient
-} from "./chunk-GCLZEI3R.js";
+} from "./chunk-2B5STVCP.js";
 import "./chunk-APMYKJI2.js";
 import {
   assertOk
 } from "./chunk-PBBULTAG.js";
-import "./chunk-WXRS5PRL.js";
+import "./chunk-ADDCQBGR.js";
 import "./chunk-U7TEQCBN.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";

package/{bugs-6PTC6V7S.js → bugs-SF56YATZ.js}

@@ -17,24 +17,24 @@ import {
 } from "./chunk-AFUXQ3P4.js";
 import {
   createHostContextsMap
-} from "./chunk-BFR3XHEM.js";
+} from "./chunk-B2CTWVQM.js";
 import "./chunk-TOKUDCSW.js";
 import "./chunk-BCANUHR3.js";
 import "./chunk-G2YT2GWF.js";
 import "./chunk-CRGWLUGC.js";
 import {
   PackageInfoClient
-} from "./chunk-TL5SYXSC.js";
+} from "./chunk-7DHDJ5XY.js";
 import "./chunk-SRWDPPLX.js";
 import "./chunk-WGDTG44V.js";
 import "./chunk-J4NHRZX6.js";
 import {
   Query,
   actual
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   SecurityArchive
-} from "./chunk-MVD5AUNS.js";
+} from "./chunk-XUGOPOLF.js";
 import {
   commandUsage
 } from "./chunk-LHIDMYN2.js";
@@ -48,7 +48,7 @@ import "./chunk-XU5WNX4S.js";
 import "./chunk-HTOTG4TS.js";
 import "./chunk-APMYKJI2.js";
 import "./chunk-PBBULTAG.js";
-import "./chunk-WXRS5PRL.js";
+import "./chunk-ADDCQBGR.js";
 import "./chunk-U7TEQCBN.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";

package/{build-R6OJNJDU.js → build-RRJ645SV.js}

@@ -11,8 +11,8 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   build
-} from "./chunk-QGFDMXDH.js";
-import "./chunk-MVD5AUNS.js";
+} from "./chunk-ZZFFMXI2.js";
+import "./chunk-XUGOPOLF.js";
 import {
   commandUsage
 } from "./chunk-LHIDMYN2.js";
@@ -21,7 +21,7 @@ import "./chunk-JIQBZ2UT.js";
 import "./chunk-64VFL4WI.js";
 import "./chunk-XU5WNX4S.js";
 import "./chunk-HTOTG4TS.js";
-import "./chunk-WXRS5PRL.js";
+import "./chunk-ADDCQBGR.js";
 import "./chunk-U7TEQCBN.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";

package/{cache-NVLCCVWQ.js → cache-NETXHYQU.js}

@@ -34,12 +34,12 @@ import {
 import "./chunk-XU5WNX4S.js";
 import {
   CacheEntry
-} from "./chunk-GCLZEI3R.js";
+} from "./chunk-2B5STVCP.js";
 import "./chunk-APMYKJI2.js";
 import {
   assertOk
 } from "./chunk-PBBULTAG.js";
-import "./chunk-WXRS5PRL.js";
+import "./chunk-ADDCQBGR.js";
 import "./chunk-U7TEQCBN.js";
 import "./chunk-XNLSTHDK.js";
 import {

package/{chunk-GCLZEI3R.js → chunk-2B5STVCP.js}

@@ -21,7 +21,7 @@ import {
 } from "./chunk-PBBULTAG.js";
 import {
   userAgent
-} from "./chunk-WXRS5PRL.js";
+} from "./chunk-ADDCQBGR.js";
 import {
   I,
   logRequest

package/{chunk-B5AKQ5TS.js → chunk-35OBZITS.js}

@@ -11,7 +11,7 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   PackageInfoClient
-} from "./chunk-TL5SYXSC.js";
+} from "./chunk-7DHDJ5XY.js";
 import {
   Monorepo,
   PackageJson,

package/{chunk-CYN4ADWK.js → chunk-75F2WCA5.js}

@@ -15,7 +15,7 @@ import {
   pairsToRecords,
   registrySelectionFields,
   registrySelectors
-} from "./chunk-B5AKQ5TS.js";
+} from "./chunk-35OBZITS.js";
 import {
   normalizeRegistryURL
 } from "./chunk-J4NHRZX6.js";

package/{chunk-TL5SYXSC.js → chunk-7DHDJ5XY.js}

@@ -46,7 +46,7 @@ import {
 
 // ../../src/package-info/src/resolve-batch.ts
 import { createInterface } from "node:readline";
-var fetchResolve = async (client, registry, request, onRecord) => {
+var fetchResolve = async (client, registry, request, onRecord, signal) => {
   if (!request.roots.length) return;
   let body;
   try {
@@ -56,6 +56,7 @@ var fetchResolve = async (client, registry, request, onRecord) => {
         // POST, not QUERY: CloudFront's allowed-method sets are fixed and
         // none includes QUERY. The registry answers both.
         method: "POST",
+        signal,
         headers: {
           "content-type": "application/json",
           accept: "application/x-ndjson"
@@ -203,9 +204,9 @@ var VLT_PACKUMENT_V2_MIME = "application/vnd.vlt.packument-v2+json";
 var PACKUMENT_ACCEPT = `${VLT_PACKUMENT_V2_MIME}; q=1.0, ${VLT_PACKUMENT_MIME}; q=0.9, application/json; q=0.8, */*; q=0.1`;
 var resolveWaitMs = () => {
   const configured = Number(process.env.VLT_BATCH_RESOLVE_WAIT_MS);
-  return Number.isFinite(configured) && configured >= 0 ? configured : 1e3;
+  return Number.isFinite(configured) && configured >= 0 ? configured : 250;
 };
-var stalled = /* @__PURE__ */ Symbol("stalled");
+var graceOver = /* @__PURE__ */ Symbol("graceOver");
 var SELECTION_OPTIONS = [
   "before",
   "os",
@@ -275,10 +276,19 @@ var PackageInfoClient = class {
   // `${registry}${name}@${range}` for every spec that chose a version and
   // `${registry}${name}@${version}` for the version itself.
   #resolvedManifests = /* @__PURE__ */ new Map();
-  // The resolves still streaming, per registry, each settling when its
-  // stream ends. The requests overlap whatever the graph build does before
-  // it asks for its first manifest.
+  /**
+   * The resolve requests in flight against each registry, with when the
+   * registry last delivered a record: the grace a lookup gives the stream
+   * is measured from there, and it is set when the request is sent, so
+   * a registry with a request in flight always has a time.
+   */
   #resolveInflight = /* @__PURE__ */ new Map();
+  /**
+   * each request in flight, by its `#resolveSent` key: its controller and
+   * how many builds are still reading it. a request that settled on its
+   * own stays in `#resolveSent`, since its records are still here
+   */
+  #resolveOwners = /* @__PURE__ */ new Map();
   // Requests already sent, so the same ask is not repeated. Keyed on the
   // request rather than the registry: a later step asking for a different
   // root set is a different question.
@@ -287,15 +297,11 @@ var PackageInfoClient = class {
   // it. Waiting per key rather than on the whole response is what lets a
   // build place level N while the server still walks level N+1.
   #resolveWaiters = /* @__PURE__ */ new Map();
-  // When each registry's resolve last delivered a record, which is what a
-  // waiter checks to tell a stream that is still coming from one that has
-  // stalled.
-  #resolveLastRecordAt = /* @__PURE__ */ new Map();
   #registryClientPromise;
   #tarPoolPromise;
   async getRegistryClient() {
     if (this.#registryClient) return this.#registryClient;
-    this.#registryClientPromise ??= import("./src-LH2HZ6FT.js").then(({ RegistryClient }) => {
+    this.#registryClientPromise ??= import("./src-ODLA6WPY.js").then(({ RegistryClient }) => {
       this.#registryClient = new RegistryClient(this.options);
       return this.#registryClient;
     });
@@ -554,7 +560,7 @@ var PackageInfoClient = class {
       }
       case "remote": {
         const rc = await this.getRegistryClient();
-        const { CacheEntry: Entry, cacheKey } = await import("./src-LH2HZ6FT.js");
+        const { CacheEntry: Entry, cacheKey } = await import("./src-ODLA6WPY.js");
         const key = cacheKey("GET", new URL(r.resolved));
         const unzipped = (entry) => {
           try {
@@ -894,46 +900,90 @@ var PackageInfoClient = class {
    *
    * A no-op unless the registry says it serves the endpoint. Anything it
    * does not deliver is left to `manifest()`.
+   *
+   * Returns the function that releases the request. A build calls it once
+   * it has placed its last node; when the last build reading a request has
+   * released it, the stream is ended, so an install never waits on a
+   * stream nothing will read. The records it delivered stay answerable.
    */
   prefetchResolve(registry, request) {
-    if (!request.roots.length) return;
+    if (!request.roots.length) return () => {
+    };
     if (!registry.endsWith("/")) registry += "/";
     const sent = `${registry}\0${JSON.stringify(request)}`;
-    if (this.#resolveSent.has(sent)) return;
+    const owned = this.#resolveOwners.get(sent);
+    if (owned) {
+      owned.readers++;
+      return () => this.#releaseResolve(sent, owned);
+    }
+    if (this.#resolveSent.has(sent)) return () => {
+    };
     this.#resolveSent.add(sent);
-    const promise = this.#runResolve(registry, request);
+    const owner = { controller: new AbortController(), readers: 1 };
+    this.#resolveOwners.set(sent, owner);
     let inflight = this.#resolveInflight.get(registry);
-    if (!inflight)
-      this.#resolveInflight.set(registry, inflight = /* @__PURE__ */ new Set());
-    inflight.add(promise);
-    const clear = () => inflight.delete(promise);
+    if (!inflight) {
+      inflight = { requests: /* @__PURE__ */ new Set(), lastRecordAt: 0 };
+      this.#resolveInflight.set(registry, inflight);
+    }
+    inflight.lastRecordAt = Date.now();
+    const promise = this.#runResolve(
+      registry,
+      request,
+      owner.controller.signal,
+      inflight
+    );
+    inflight.requests.add(promise);
+    const clear = () => {
+      inflight.requests.delete(promise);
+      if (this.#resolveOwners.get(sent) === owner)
+        this.#resolveOwners.delete(sent);
+    };
     promise.then(clear, clear);
+    return () => this.#releaseResolve(sent, owner);
+  }
+  /**
+   * One build is done reading the request; the last one out ends it, and
+   * the same question can then be asked again.
+   */
+  #releaseResolve(sent, owner) {
+    if (--owner.readers > 0) return;
+    if (this.#resolveOwners.get(sent) === owner) {
+      this.#resolveOwners.delete(sent);
+      this.#resolveSent.delete(sent);
+    }
+    owner.controller.abort();
   }
   /** Never rejects: a resolve that fails leaves every spec to manifest(). */
-  async #runResolve(registry, request) {
+  async #runResolve(registry, request, signal, inflight) {
     try {
       if ((await this.capabilities(registry)).resolve === void 0)
         return;
       const client = await this.getRegistryClient();
-      this.#resolveLastRecordAt.set(registry, Date.now());
-      await fetchResolve(client, registry, request, (record) => {
-        this.#resolveLastRecordAt.set(registry, Date.now());
-        absolutizeTarball(
-          record.manifest,
-          `${registry}${record.name}/-/`
-        );
-        this.#vltPackuments.add(`${registry}${record.name}`);
-        for (const spec of record.requested) {
+      await fetchResolve(
+        client,
+        registry,
+        request,
+        (record) => {
+          inflight.lastRecordAt = Date.now();
+          absolutizeTarball(
+            record.manifest,
+            `${registry}${record.name}/-/`
+          );
+          this.#vltPackuments.add(`${registry}${record.name}`);
+          for (const spec of record.requested) {
+            this.#deliverResolved(
+              `${registry}${record.name}@${spec}`,
+              record.manifest
+            );
+          }
           this.#deliverResolved(
-            `${registry}${record.name}@${spec}`,
+            `${registry}${record.name}@${record.version}`,
             record.manifest
           );
-        }
-        this.#deliverResolved(
-          `${registry}${record.name}@${record.version}`,
-          record.manifest
-        );
-      });
+        },
+        signal
+      );
     } catch {
     }
   }
@@ -948,17 +998,20 @@ var PackageInfoClient = class {
     }
   }
   /**
-   * The manifest an in-flight resolve is expected to carry for `key`, or
-   * undefined once waiting stopped being worth it: every request settled
-   * without the key, or no record of any kind arrived for a whole wait.
+   * The manifest for `key` from an in-flight resolve, or from `fetch` when
+   * the resolve is not carrying it. Undefined when nothing is in flight.
    *
-   * A stream that is still delivering is worth waiting on, since its records
-   * come in the order the build needs them; one that has stalled is not, and
-   * the packument fetch was the alternative anyway.
+   * A stream that is delivering gets a short grace to carry the key, since
+   * its records come in the order the build asks for them; one that has
+   * gone quiet gets none, so a server that is slow to start never charges
+   * that grace to every level of the build. After the grace `fetch` runs as
+   * well and the first answer wins, so a slow server can never hold a
+   * lookup longer than fetching the packument would have. A fetch that
+   * fails while the stream is still open waits for the stream's verdict.
    */
-  async #awaitResolved(registry, key) {
+  async #awaitResolved(registry, key, fetch) {
     const inflight = this.#resolveInflight.get(registry);
-    if (!inflight?.size) return void 0;
+    if (!inflight?.requests.size) return void 0;
     let wake;
     const arrival = new Promise((res) => {
       wake = res;
@@ -966,22 +1019,33 @@ var PackageInfoClient = class {
     let waiters = this.#resolveWaiters.get(key);
     if (!waiters) this.#resolveWaiters.set(key, waiters = /* @__PURE__ */ new Set());
     waiters.add(wake);
-    const settled = Promise.all([...inflight]).then(
+    const settled = Promise.all([...inflight.requests]).then(
       () => this.#resolvedManifests.get(key)
     );
-    const waitMs = resolveWaitMs();
+    const quietFor = Date.now() - inflight.lastRecordAt;
+    const grace = Math.max(0, resolveWaitMs() - quietFor);
     try {
-      for (; ; ) {
-        const outcome = await Promise.race([
-          arrival,
-          settled,
-          // unref'd: a pending wait must never be what keeps the process up
-          setTimeout(waitMs, stalled, { ref: false })
-        ]);
-        if (outcome !== stalled) return outcome;
-        const lastRecordAt = this.#resolveLastRecordAt.get(registry) ?? 0;
-        if (Date.now() - lastRecordAt >= waitMs) return void 0;
-      }
+      const early = await Promise.race([
+        arrival,
+        settled,
+        // unref'd: a pending wait must never be what keeps the process up
+        setTimeout(grace, graceOver, { ref: false })
+      ]);
+      if (early !== graceOver) return early ?? await fetch();
+      debug("resolve hedge %s", key);
+      const hedge = fetch();
+      const outcome = await Promise.race([
+        arrival,
+        settled,
+        hedge.catch(() => void 0)
+      ]);
+      if (outcome) return outcome;
+      const found = await Promise.race([
+        arrival,
+        settled,
+        setTimeout(resolveWaitMs(), graceOver, { ref: false })
+      ]);
+      return found && found !== graceOver ? found : await hedge;
     } finally {
       waiters.delete(wake);
       if (!waiters.size) this.#resolveWaiters.delete(key);
@@ -998,15 +1062,13 @@ var PackageInfoClient = class {
     const f = spec.final;
     switch (f.type) {
       case "registry": {
-        if (!SELECTION_OPTIONS.some((k) => options[k] !== void 0)) {
-          const key = `${f.registry ?? ""}${f.name}@${f.bareSpec}`;
-          const resolved = this.#resolvedManifests.get(key);
+        const selecting = SELECTION_OPTIONS.some(
+          (k) => options[k] !== void 0
+        );
+        const resolveKey = `${f.registry ?? ""}${f.name}@${f.bareSpec}`;
+        if (!selecting) {
+          const resolved = this.#resolvedManifests.get(resolveKey);
           if (resolved) return resolved;
-          if (f.registry) {
-            const arrived = await this.#awaitResolved(f.registry, key);
-            if (arrived) return arrived;
-            debug("resolve miss %s", key);
-          }
         }
         const cachePath = this._manifestCachePath(spec, options);
         if (cachePath) {
@@ -1030,25 +1092,36 @@ var PackageInfoClient = class {
           } catch {
           }
         }
-        const mani = pickManifest(
-          await this.#packument(f, options, this.#stable(f)),
-          spec,
-          options
-        );
-        if (!mani) throw this.#resolveError(spec, options);
-        if (cachePath && !this.#manifestWritePaths.has(cachePath)) {
-          this.#manifestWritePaths.add(cachePath);
-          const vlt = this.#vltPackuments.has(
-            `${f.registry}${f.name}`
+        const fromPackument = async () => {
+          const mani = pickManifest(
+            await this.#packument(f, options, this.#stable(f)),
+            spec,
+            options
           );
-          void this.#writeManifestCache(
-            cachePath,
-            JSON.stringify(
-              vlt ? { ...mani, __VLT_PACKUMENT: true } : mani
-            )
+          if (!mani) throw this.#resolveError(spec, options);
+          if (cachePath && !this.#manifestWritePaths.has(cachePath)) {
+            this.#manifestWritePaths.add(cachePath);
+            const vlt = this.#vltPackuments.has(
+              `${f.registry}${f.name}`
+            );
+            void this.#writeManifestCache(
+              cachePath,
+              JSON.stringify(
+                vlt ? { ...mani, __VLT_PACKUMENT: true } : mani
+              )
+            );
+          }
+          return mani;
+        };
+        if (!selecting && f.registry) {
+          const resolved = await this.#awaitResolved(
+            f.registry,
+            resolveKey,
+            fromPackument
           );
+          if (resolved) return resolved;
         }
-        return mani;
+        return fromPackument();
       }
       case "git": {
         const {

package/{chunk-WXRS5PRL.js → chunk-ADDCQBGR.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.3.4",
+  version: "1.3.5",
   repository: {
     type: "git",
     url: "git+https://github.com/vltpkg/vltpkg.git",

package/{chunk-BFR3XHEM.js → chunk-B2CTWVQM.js}

@@ -13,10 +13,10 @@ import {
   actual,
   callLimit,
   createVirtualRoot
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   SecurityArchive
-} from "./chunk-MVD5AUNS.js";
+} from "./chunk-XUGOPOLF.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -140,7 +140,7 @@ var reloadConfig = async (folder) => {
     unload("project");
   } catch {
   }
-  const { Config } = await import("./config-EV5S74AA.js");
+  const { Config } = await import("./config-HO7N7FPS.js");
   return Config.load(folder, process.argv, true);
 };
 

package/{chunk-DK6HGJCF.js → chunk-EGWLQVDZ.js}

@@ -17,13 +17,13 @@ import {
 } from "./chunk-TOKUDCSW.js";
 import {
   mermaidOutput
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   ViewClass
 } from "./chunk-4KCU2KZL.js";
 import {
   getTokenByURL
-} from "./chunk-GCLZEI3R.js";
+} from "./chunk-2B5STVCP.js";
 
 // ../../src/cli-sdk/src/query-auth.ts
 var createGetAuthHeader = (conf) => async (url) => getTokenByURL(url, conf.options.identity);

package/chunk-EWZQGHYC.js

@@ -0,0 +1,75 @@
+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 {
+  error
+} from "./chunk-WZWDS3W4.js";
+import {
+  __glob
+} from "./chunk-PZLD7RTK.js";
+
+// import("./commands/**/*.ts") in ../../src/cli-sdk/src/load-command.ts
+var globImport_commands_ts = __glob({
+  "./commands/access.ts": () => import("./access-X2ZZH2BV.js"),
+  "./commands/bugs.ts": () => import("./bugs-SF56YATZ.js"),
+  "./commands/build.ts": () => import("./build-RRJ645SV.js"),
+  "./commands/cache.ts": () => import("./cache-NETXHYQU.js"),
+  "./commands/ci.ts": () => import("./ci-YX56QIMV.js"),
+  "./commands/config.ts": () => import("./config-SHRCBOCI.js"),
+  "./commands/create.ts": () => import("./create-LO6BUYPU.js"),
+  "./commands/deprecate.ts": () => import("./deprecate-CUMWWMAF.js"),
+  "./commands/dist-tag.ts": () => import("./dist-tag-DJJDBPTJ.js"),
+  "./commands/docs.ts": () => import("./docs-KDCDJRO5.js"),
+  "./commands/exec-cache.ts": () => import("./exec-cache-GBLLYU5O.js"),
+  "./commands/exec-local.ts": () => import("./exec-local-VCP4KR6K.js"),
+  "./commands/exec.ts": () => import("./exec-KF4ANRPM.js"),
+  "./commands/help.ts": () => import("./help-MV53HEUI.js"),
+  "./commands/init.ts": () => import("./init-N3BM2FKC.js"),
+  "./commands/install.ts": () => import("./install-DDYIRJWL.js"),
+  "./commands/install/reporter.ts": () => import("./reporter-K3D4AJBF.js"),
+  "./commands/list.ts": () => import("./list-VTCG6GBS.js"),
+  "./commands/login.ts": () => import("./login-MCX6LCP5.js"),
+  "./commands/logout.ts": () => import("./logout-FPNGIQDZ.js"),
+  "./commands/pack.ts": () => import("./pack-KCVLNNVZ.js"),
+  "./commands/ping.ts": () => import("./ping-MXTB7GFE.js"),
+  "./commands/pkg.ts": () => import("./pkg-QDEHGO34.js"),
+  "./commands/profile.ts": () => import("./profile-GQUM6NRG.js"),
+  "./commands/publish.ts": () => import("./publish-UEL4KXDZ.js"),
+  "./commands/query.ts": () => import("./query-MJTEJIZW.js"),
+  "./commands/registry.ts": () => import("./registry-PY2L5ZWC.js"),
+  "./commands/repo.ts": () => import("./repo-XDMXV744.js"),
+  "./commands/run-exec.ts": () => import("./run-exec-Q7JNLVVV.js"),
+  "./commands/run.ts": () => import("./run-MKEP7YKW.js"),
+  "./commands/setup.ts": () => import("./setup-DYQY6DIX.js"),
+  "./commands/token.ts": () => import("./token-RUBMQURU.js"),
+  "./commands/uninstall.ts": () => import("./uninstall-3NJXWOKS.js"),
+  "./commands/unpublish.ts": () => import("./unpublish-3ETADFWK.js"),
+  "./commands/update.ts": () => import("./update-L6ETRX6Q.js"),
+  "./commands/version.ts": () => import("./version-RHWAFXPK.js"),
+  "./commands/view.ts": () => import("./view-ABHAULFH.js"),
+  "./commands/whoami.ts": () => import("./whoami-YDR7Q4VT.js")
+});
+
+// ../../src/cli-sdk/src/load-command.ts
+var loadCommand = async (command) => {
+  try {
+    return await globImport_commands_ts(`./commands/${command}.ts`);
+  } catch (e) {
+    throw error("Could not load command", {
+      found: command,
+      cause: e
+    });
+  }
+};
+
+export {
+  loadCommand
+};

package/{chunk-MWAWPY3P.js → chunk-GO5X2SSV.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   init,
   install
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   commandUsage
 } from "./chunk-LHIDMYN2.js";

package/{chunk-QEWKCTQY.js → chunk-I2DZC2J3.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-RIYFGX27.js";
 import {
   createHostContextsMap
-} from "./chunk-BFR3XHEM.js";
+} from "./chunk-B2CTWVQM.js";
 import {
   stderr,
   stdout,
@@ -27,7 +27,7 @@ import {
   Query,
   actual,
   isRunResult
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   Monorepo
 } from "./chunk-INEKXXUQ.js";

package/{chunk-D4KNFORN.js → chunk-LHB4CVEH.js}

@@ -24,7 +24,7 @@ var run = async (command) => {
   if (command) {
     process.argv.splice(2, 0, command);
   }
-  const vlt = await import("./src-SI5YMOJI.js");
+  const vlt = await import("./src-BZJHOEYT.js");
   await vlt.default();
 };
 

package/{chunk-QZIC3WVP.js → chunk-PBHCZOUY.js}

@@ -11,11 +11,11 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   PackageInfoClient
-} from "./chunk-TL5SYXSC.js";
+} from "./chunk-7DHDJ5XY.js";
 import {
   findCmdShimIfExists,
   install
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   PathScurry
 } from "./chunk-INEKXXUQ.js";

package/{chunk-4XTUCYBW.js → chunk-QJHTK7ML.js}

@@ -15,7 +15,7 @@ import {
 import {
   addKey,
   asDependency
-} from "./chunk-QGFDMXDH.js";
+} from "./chunk-ZZFFMXI2.js";
 import {
   joinDepIDTuple,
   splitDepID