@vltpkg/cli-js 1.3.2 → 1.3.4

package/{chunk-ZMRJRQDK.js → chunk-TL5SYXSC.js}

@@ -10,9 +10,8 @@ globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
-  Qn,
-  require_lib
-} from "./chunk-ZWKI5OSF.js";
+  Qn
+} from "./chunk-SRWDPPLX.js";
 import {
   Monorepo,
   PackageJson,
@@ -20,7 +19,7 @@ import {
   pickManifest,
   resolve,
   revs
-} from "./chunk-BUKZHMMK.js";
+} from "./chunk-INEKXXUQ.js";
 import {
   Spec
 } from "./chunk-64VFL4WI.js";
@@ -44,12 +43,66 @@ import {
 import {
   error
 } from "./chunk-WZWDS3W4.js";
-import {
-  __toESM
-} from "./chunk-PZLD7RTK.js";
+
+// ../../src/package-info/src/resolve-batch.ts
+import { createInterface } from "node:readline";
+var fetchResolve = async (client, registry, request, onRecord) => {
+  if (!request.roots.length) return;
+  let body;
+  try {
+    const response = await client.requestStream(
+      new URL("-/vlt/resolve", registry),
+      {
+        // POST, not QUERY: CloudFront's allowed-method sets are fixed and
+        // none includes QUERY. The registry answers both.
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/x-ndjson"
+        },
+        body: JSON.stringify(request)
+      }
+    );
+    if (response.statusCode !== 207) {
+      response.body.resume();
+      return;
+    }
+    body = response.body;
+  } catch {
+    return;
+  }
+  try {
+    for await (const line of createInterface({ input: body })) {
+      const record = parseRecord(line);
+      if (record) onRecord(record);
+    }
+  } catch {
+    body.destroy();
+  }
+};
+var parseRecord = (l) => {
+  let record;
+  try {
+    record = JSON.parse(l);
+  } catch {
+    return;
+  }
+  const { status, name, requested, manifest } = record;
+  if (status !== 200 || typeof name !== "string") return;
+  if (!Array.isArray(requested) || !requested.every((s) => typeof s === "string"))
+    return;
+  if (typeof manifest !== "object" || manifest === null) return;
+  const mani = manifest;
+  if (mani.name !== name || typeof mani.version !== "string") return;
+  return {
+    name,
+    version: mani.version,
+    requested,
+    manifest: mani
+  };
+};
 
 // ../../src/package-info/src/index.ts
-var import_ssri = __toESM(require_lib(), 1);
 import { createHash, randomBytes } from "node:crypto";
 import {
   mkdir,
@@ -66,6 +119,7 @@ import {
   resolve as pathResolve,
   relative
 } from "node:path";
+import { setTimeout } from "node:timers/promises";
 import { debuglog } from "node:util";
 
 // ../../src/package-info/src/capabilities.ts
@@ -147,18 +201,32 @@ var delimiter = "~";
 var VLT_PACKUMENT_MIME = "application/vnd.vlt.packument-v1+json";
 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;
+};
+var stalled = /* @__PURE__ */ Symbol("stalled");
+var SELECTION_OPTIONS = [
+  "before",
+  "os",
+  "arch",
+  "libc",
+  "node-version"
+];
 var manifestCacheMaxAge = 5 * 60 * 1e3;
 var noRegistryError = (spec) => error(
   'No registry configured to resolve this spec. Set "registry" in vlt.json, pass --registry, or run `vlt login --registry=<url>`. See https://docs.vlt.sh/cli',
   { code: "ECONFIG", spec }
 );
 var isMovingSelector = (f) => !!(f.distTag || f.range?.isAny);
+var revalidateMode = (f, options) => !isMovingSelector(f) ? void 0 : options.backgroundRevalidate ? "background" : true;
 var isStableSelector = (f) => {
   const { range } = f;
   if (!range) return false;
   return !range.isAny && !range.raw.includes("-");
 };
 var storeLinkers = /* @__PURE__ */ new Set(["auto", "hardlink", "copy"]);
+var storedIntegrity = (response) => !response.fromCache ? response.integrityActual : !response.contentType ? void 0 : response.integrity ?? (response.isGzip ? response.integrityActual : void 0);
 var PackageInfoClient = class {
   #registryClient;
   #projectRoot;
@@ -191,8 +259,8 @@ var PackageInfoClient = class {
   // In-flight coalescing key is `${registry}${name}` — no representation
   // component. Safe only because every caller requests the same full
   // packument (see #fetchPackument). The one thing that does vary per
-  // caller is forceRevalidate, so record it and let a moving selector
-  // reuse a forced promise but never a non-forced one (see packument()).
+  // caller is forceRevalidate, so record how hard it revalidates and
+  // never let a request ride a weaker one (see #packument()).
   #packumentPromises = /* @__PURE__ */ new Map();
   // unique temp file names for atomic manifest cache writes
   #manifestWriteRandom = randomBytes(6).toString("hex");
@@ -203,11 +271,31 @@ var PackageInfoClient = class {
   // needed. entries are removed when the on-disk file is invalidated
   // so the refreshed manifest can be written again.
   #manifestWritePaths = /* @__PURE__ */ new Set();
+  // Manifests a resolve batch delivered, keyed both as
+  // `${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.
+  #resolveInflight = /* @__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.
+  #resolveSent = /* @__PURE__ */ new Set();
+  // Keys `manifest()` is waiting for, each woken by the record that carries
+  // 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-3UQFZRM3.js").then(({ RegistryClient }) => {
+    this.#registryClientPromise ??= import("./src-LH2HZ6FT.js").then(({ RegistryClient }) => {
       this.#registryClient = new RegistryClient(this.options);
       return this.#registryClient;
     });
@@ -247,7 +335,7 @@ var PackageInfoClient = class {
   }
   async getTarPool() {
     if (this.#tarPool) return this.#tarPool;
-    this.#tarPoolPromise ??= import("./src-EJSVFFXB.js").then(
+    this.#tarPoolPromise ??= import("./src-3MEJQYBG.js").then(
       ({ Pool }) => {
         this.#tarPool = new Pool();
         return this.#tarPool;
@@ -297,8 +385,7 @@ var PackageInfoClient = class {
       from = this.#projectRoot,
       integrity,
       resolved,
-      fromLockfile = false,
-      installScripts = false
+      fromLockfile = false
     } = options;
     const f = spec.final;
     const brotli = !!resolved && tarballFormat(resolved) === "brotli";
@@ -344,7 +431,7 @@ var PackageInfoClient = class {
         const pool = await this.getTarPool();
         const format = tarballFormat(r.resolved);
         const storeOn = f.type === "registry" && this.#storeLinker !== "unpack";
-        const copy = this.#storeLinker === "copy" || installScripts;
+        const copy = this.#storeLinker === "copy";
         const hex = !storeOn ? void 0 : r.integrity ? integrityHex(r.integrity) : integrityHex(
           (await this.getRegistryClient()).cachedIntegrity(
             r.resolved
@@ -466,30 +553,71 @@ var PackageInfoClient = class {
         return r;
       }
       case "remote": {
-        const response = await (await this.getRegistryClient()).request(r.resolved);
-        if (response.statusCode !== 200) {
-          throw this.#resolveError(
-            spec,
-            options,
-            `failed to fetch remote tarball: ${registryErrorMessage(response)}`,
-            {
-              url: r.resolved,
-              response
+        const rc = await this.getRegistryClient();
+        const { CacheEntry: Entry, cacheKey } = await import("./src-LH2HZ6FT.js");
+        const key = cacheKey("GET", new URL(r.resolved));
+        const unzipped = (entry) => {
+          try {
+            return entry.unzippedIntegrity() === r.integrity;
+          } catch {
+            return false;
+          }
+        };
+        const fetchTarball = async (readCache) => {
+          let response2;
+          try {
+            response2 = await rc.request(r.resolved, {
+              integrity: r.integrity,
+              ...readCache === false ? { readCache } : {}
+            });
+          } catch (er) {
+            const cause = er.cause;
+            if (cause?.code !== "EINTEGRITY" || !(cause.response instanceof Entry) || !unzipped(cause.response)) {
+              throw er;
             }
-          );
+            response2 = cause.response;
+            r.integrity = response2.integrityActual;
+            response2.labelArtifact();
+            rc.cache.set(key, response2.encode(), {
+              integrity: r.integrity
+            });
+          }
+          if (response2.statusCode !== 200) {
+            throw this.#resolveError(
+              spec,
+              options,
+              `failed to fetch remote tarball: ${registryErrorMessage(response2)}`,
+              {
+                url: r.resolved,
+                response: response2
+              }
+            );
+          }
+          return response2;
+        };
+        let response = await fetchTarball();
+        let found = storedIntegrity(response);
+        if (response.fromCache && found && r.integrity && r.integrity !== found && unzipped(response)) {
+          r.integrity = found;
         }
-        const buf = response.buffer();
-        const computed = import_ssri.default.fromData(buf, { algorithms: ["sha512"] }).toString();
-        if (r.integrity && r.integrity !== computed) {
+        if (response.fromCache && (!found || r.integrity && r.integrity !== found)) {
+          rc.cache.delete(key, true, found);
+          if (r.integrity) rc.cache.delete(key, true, r.integrity);
+          await rc.cache.promise();
+          response = await fetchTarball(false);
+          found = storedIntegrity(response);
+        }
+        if (!found || r.integrity && r.integrity !== found) {
           throw error("Integrity check failure", {
             code: "EINTEGRITY",
             spec,
             url: r.resolved,
             wanted: r.integrity,
-            found: computed
+            found
           });
         }
-        r.integrity = computed;
+        r.integrity = found;
+        const buf = response.buffer();
         try {
           await (await this.getTarPool()).unpack(buf, target);
         } catch (er) {
@@ -759,6 +887,110 @@ var PackageInfoClient = class {
       }
     }
   }
+  /**
+   * Start a server-side resolve for `request` against `registry` and
+   * return without waiting. `manifest()` answers from what has arrived,
+   * and blocks on the request only when it needs a key that has not.
+   *
+   * A no-op unless the registry says it serves the endpoint. Anything it
+   * does not deliver is left to `manifest()`.
+   */
+  prefetchResolve(registry, request) {
+    if (!request.roots.length) return;
+    if (!registry.endsWith("/")) registry += "/";
+    const sent = `${registry}\0${JSON.stringify(request)}`;
+    if (this.#resolveSent.has(sent)) return;
+    this.#resolveSent.add(sent);
+    const promise = this.#runResolve(registry, request);
+    let inflight = this.#resolveInflight.get(registry);
+    if (!inflight)
+      this.#resolveInflight.set(registry, inflight = /* @__PURE__ */ new Set());
+    inflight.add(promise);
+    const clear = () => inflight.delete(promise);
+    promise.then(clear, clear);
+  }
+  /** Never rejects: a resolve that fails leaves every spec to manifest(). */
+  async #runResolve(registry, request) {
+    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) {
+          this.#deliverResolved(
+            `${registry}${record.name}@${spec}`,
+            record.manifest
+          );
+        }
+        this.#deliverResolved(
+          `${registry}${record.name}@${record.version}`,
+          record.manifest
+        );
+      });
+    } catch {
+    }
+  }
+  /** Record an arrived manifest and wake whoever was waiting for it. */
+  #deliverResolved(key, manifest) {
+    debug("resolve delivered %s", key);
+    this.#resolvedManifests.set(key, manifest);
+    const waiters = this.#resolveWaiters.get(key);
+    if (waiters) {
+      this.#resolveWaiters.delete(key);
+      for (const wake of waiters) wake(manifest);
+    }
+  }
+  /**
+   * 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.
+   *
+   * 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.
+   */
+  async #awaitResolved(registry, key) {
+    const inflight = this.#resolveInflight.get(registry);
+    if (!inflight?.size) return void 0;
+    let wake;
+    const arrival = new Promise((res) => {
+      wake = res;
+    });
+    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(
+      () => this.#resolvedManifests.get(key)
+    );
+    const waitMs = resolveWaitMs();
+    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;
+      }
+    } finally {
+      waiters.delete(wake);
+      if (!waiters.size) this.#resolveWaiters.delete(key);
+    }
+  }
+  /** How many manifests resolve batches have delivered. For tests. */
+  get resolvedManifestCount() {
+    return this.#resolvedManifests.size;
+  }
   async manifest(spec, options = {}) {
     const { from = this.#projectRoot } = options;
     if (typeof spec === "string")
@@ -766,6 +998,16 @@ 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);
+          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) {
           try {
@@ -848,7 +1090,7 @@ var PackageInfoClient = class {
             );
           }
           const buf = response.buffer();
-          const computed = import_ssri.default.fromData(buf, { algorithms: ["sha512"] }).toString();
+          const integrity = storedIntegrity(response);
           try {
             await (await this.getTarPool()).unpack(buf, dir);
           } catch (er) {
@@ -860,7 +1102,7 @@ var PackageInfoClient = class {
             );
           }
           const mani = this.#readExtracted(dir, s, options);
-          mani.dist = { integrity: computed };
+          if (integrity) mani.dist = { integrity };
           return mani;
         });
       }
@@ -948,19 +1190,19 @@ var PackageInfoClient = class {
           );
         const fullKey = `${registry}${name}`;
         const packumentKey = stable ? `${fullKey}?stable` : fullKey;
-        const forced = isMovingSelector(f);
+        const mode = revalidateMode(f, options);
+        const rank = mode === true ? 2 : mode ? 1 : 0;
         const inflight = this.#packumentPromises.get(packumentKey) ?? // the full packument is a superset of the stable one, so an
         // in-flight full request answers a stable ask too, and a package
         // wanted both ways is still fetched once
         (stable ? this.#packumentPromises.get(fullKey) : void 0);
-        if (inflight && (!forced || inflight.forced))
-          return inflight.promise;
+        if (inflight && inflight.rank >= rank) return inflight.promise;
         const pakuURL = new URL(
           stable ? `${name}?stable` : name,
           registry
         );
         const promise = this.#fetchPackument(spec, options, pakuURL);
-        const record = { promise, forced };
+        const record = { promise, rank };
         this.#packumentPromises.set(packumentKey, record);
         const clear = () => {
           if (this.#packumentPromises.get(packumentKey) === record) {
@@ -973,15 +1215,17 @@ var PackageInfoClient = class {
     }
   }
   async #fetchPackument(spec, options, pakuURL, useCache) {
+    const mode = revalidateMode(spec.final, options);
     const response = await (await this.getRegistryClient()).request(pakuURL, {
       headers: {
         accept: options.full ? "application/json" : PACKUMENT_ACCEPT
       },
       ...useCache === false || options.full ? { useCache: false } : {},
-      // costs a conditional GET per moving selector on an otherwise warm
-      // cache, install included. 304s are cheap but not free; the
-      // alternative is serving a dist tag that moved (#1656).
-      ...isMovingSelector(spec.final) ? { forceRevalidate: true } : {}
+      // a moving selector pays a conditional GET before use, so a moved
+      // dist tag is seen at once (#1656). with backgroundRevalidate a
+      // packument still within max-age is served and revalidated after
+      // exit instead.
+      ...mode === void 0 ? {} : { forceRevalidate: mode }
     });
     if (response.statusCode !== 200) {
       throw this.#resolveError(
@@ -1176,11 +1420,14 @@ var PackageInfoClient = class {
   }
 };
 var absolutizeTarballs = (paku, base) => {
-  for (const { dist } of Object.values(paku.versions)) {
-    const tarball = dist?.tarball;
-    if (tarball && !/^[a-z][a-z0-9+.-]*:/i.test(tarball)) {
-      dist.tarball = String(new URL(tarball, base));
-    }
+  for (const manifest of Object.values(paku.versions)) {
+    absolutizeTarball(manifest, base);
+  }
+};
+var absolutizeTarball = (manifest, base) => {
+  const dist = manifest.dist;
+  if (dist?.tarball && !/^[a-z][a-z0-9+.-]*:/i.test(dist.tarball)) {
+    dist.tarball = String(new URL(dist.tarball, base));
   }
 };
 

package/{chunk-CSZTT7QN.js → chunk-TOKUDCSW.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   generateDefaultHelp,
   generateFullHelp
-} from "./chunk-CU752KW7.js";
+} from "./chunk-BCANUHR3.js";
 import {
   flush,
   trackCommand,
@@ -38,7 +38,7 @@ import {
 } from "./chunk-JIQBZ2UT.js";
 import {
   defaultView
-} from "./chunk-ENSGPOLR.js";
+} from "./chunk-XU5WNX4S.js";
 import {
   emitter
 } from "./chunk-U7TEQCBN.js";

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

package/{chunk-ENSGPOLR.js → chunk-XU5WNX4S.js}

@@ -1383,7 +1383,9 @@ var definition = j2.heading("Configuration").description(
                     - unpack: Unpack each package tarball, skipping the
                       global store.
 
-                    Packages with install scripts are always copied.
+                    A package is copied right before its install
+                    scripts run, so they don't change its files in the
+                    store.
                     An invalid \`VLT_STORE_LINKER\` warns and uses
                     \`unpack\`.`,
     validOptions: storeLinkers,

package/{ci-4AI6XHRE.js → ci-FEZ6B33S.js}

@@ -11,20 +11,20 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   install
-} from "./chunk-IIXKXSLE.js";
-import "./chunk-4WQ76RJD.js";
+} from "./chunk-QGFDMXDH.js";
+import "./chunk-MVD5AUNS.js";
 import {
   commandUsage
-} from "./chunk-I6QGYSB4.js";
-import "./chunk-BUKZHMMK.js";
+} from "./chunk-LHIDMYN2.js";
+import "./chunk-INEKXXUQ.js";
 import {
   lazyView
 } from "./chunk-4KCU2KZL.js";
 import "./chunk-JIQBZ2UT.js";
 import "./chunk-64VFL4WI.js";
-import "./chunk-ENSGPOLR.js";
+import "./chunk-XU5WNX4S.js";
 import "./chunk-HTOTG4TS.js";
-import "./chunk-3NWCWTIU.js";
+import "./chunk-WXRS5PRL.js";
 import "./chunk-U7TEQCBN.js";
 import "./chunk-XNLSTHDK.js";
 import "./chunk-PDWPFR5T.js";
@@ -63,7 +63,7 @@ var usage = () => commandUsage({
 var views = {
   json: (i) => i.graph.toJSON(),
   human: lazyView(
-    async () => (await import("./reporter-ZEDO2YIG.js")).InstallReporter
+    async () => (await import("./reporter-UUDMEN4E.js")).InstallReporter
   )
 };
 var command = async (conf) => {

package/cli-package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/cli-sdk",
   "description": "The source for the vlt CLI",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",

package/{config-PJVA5HZQ.js → config-EV5S74AA.js}

@@ -16,10 +16,10 @@ import {
   kCustomInspect,
   pairsToRecords,
   recordsToPairs
-} from "./chunk-4FHGRT4J.js";
-import "./chunk-ZMRJRQDK.js";
-import "./chunk-ZWKI5OSF.js";
-import "./chunk-BUKZHMMK.js";
+} from "./chunk-B5AKQ5TS.js";
+import "./chunk-TL5SYXSC.js";
+import "./chunk-SRWDPPLX.js";
+import "./chunk-INEKXXUQ.js";
 import "./chunk-JIQBZ2UT.js";
 import "./chunk-64VFL4WI.js";
 import {
@@ -27,7 +27,7 @@ import {
   definition,
   isRecordField,
   recordFields
-} from "./chunk-ENSGPOLR.js";
+} from "./chunk-XU5WNX4S.js";
 import "./chunk-HTOTG4TS.js";
 import "./chunk-PBBULTAG.js";
 import "./chunk-U7TEQCBN.js";

package/{config-UHPA5FHX.js → config-VVPVV36W.js}

@@ -19,19 +19,19 @@ import {
 import {
   pairsToRecords,
   recordsToPairs
-} from "./chunk-4FHGRT4J.js";
-import "./chunk-ZMRJRQDK.js";
-import "./chunk-ZWKI5OSF.js";
+} from "./chunk-B5AKQ5TS.js";
+import "./chunk-TL5SYXSC.js";
+import "./chunk-SRWDPPLX.js";
 import {
   commandUsage
-} from "./chunk-I6QGYSB4.js";
-import "./chunk-BUKZHMMK.js";
+} from "./chunk-LHIDMYN2.js";
+import "./chunk-INEKXXUQ.js";
 import "./chunk-JIQBZ2UT.js";
 import "./chunk-64VFL4WI.js";
 import {
   getSortedKeys,
   isRecordField
-} from "./chunk-ENSGPOLR.js";
+} from "./chunk-XU5WNX4S.js";
 import {
   find,
   load