vlt 1.6.1 → 1.6.2

package/{chunk-IHERL3TA.js → chunk-3UDBYFAH.js}

@@ -17,11 +17,11 @@ import {
   pickManifest,
   resolve,
   revs
-} from "./chunk-EMTGRCSE.js";
+} from "./chunk-GJMDZJPJ.js";
 import {
   Monorepo,
   PackageJson
-} from "./chunk-KURQHX54.js";
+} from "./chunk-6ISFYONV.js";
 import {
   Spec
 } from "./chunk-6D3QAFNZ.js";
@@ -32,10 +32,16 @@ import {
 } from "./chunk-4GMNWW4C.js";
 import {
   logRequest
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";
+import {
+  storeIndexPath
+} from "./chunk-24DWRCPS.js";
+import {
+  span
+} from "./chunk-6ETYWCJN.js";
 import {
   asPackument,
   brotliTarballUrl,
@@ -107,6 +113,7 @@ var parseRecord = (l) => {
 
 // ../../src/package-info/src/index.ts
 import { createHash, randomBytes } from "node:crypto";
+import { lstatSync } from "node:fs";
 import {
   mkdir,
   readFile,
@@ -338,7 +345,7 @@ var PackageInfoClient = class {
   }
   async getRegistryClient() {
     if (this.#registryClient) return this.#registryClient;
-    this.#registryClientPromise ??= import("./src-A5ZJNOHN.js").then(({ RegistryClient }) => {
+    this.#registryClientPromise ??= import("./src-REZNPR2X.js").then(({ RegistryClient }) => {
       this.#registryClient = new RegistryClient(this.options);
       return this.#registryClient;
     });
@@ -377,7 +384,7 @@ var PackageInfoClient = class {
   }
   async getTarPool() {
     if (this.#tarPool) return this.#tarPool;
-    this.#tarPoolPromise ??= import("./src-W2VQULRG.js").then(
+    this.#tarPoolPromise ??= import("./src-GY57R4DK.js").then(
       ({ Pool }) => {
         this.#tarPool = new Pool();
         return this.#tarPool;
@@ -385,6 +392,44 @@ var PackageInfoClient = class {
     );
     return this.#tarPoolPromise;
   }
+  /**
+   * Terminate the tar pool's placement worker threads, if any were
+   * started. Reify calls this once placement is done; it is a no-op when
+   * the pool was never created or ran inline.
+   */
+  async closeTarPool() {
+    await this.#tarPoolPromise;
+    await this.#tarPool?.close();
+  }
+  /**
+   * Start the tar pool's unpack workers for an install about to place
+   * `nodes`, so they boot while the first packages are fetched instead
+   * of on the critical path of the first unpack. Only the nodes the
+   * global store does not already hold count: a store hit is linked on
+   * the main thread, so a warm install of all hits starts no worker.
+   * Best effort and never rejects: if the pool cannot start, unpacking
+   * just runs inline, and a real failure resurfaces at the first
+   * extract.
+   */
+  async warmTarPool(nodes) {
+    try {
+      const storeOn = this.#storeLinker !== "unpack";
+      let jobs = 0;
+      for (const { integrity } of nodes) {
+        const hex = storeOn ? integrityHex(integrity) : void 0;
+        if (hex && lstatSync(
+          storeIndexPath(pathResolve(this.#storeRoot, hex)),
+          { throwIfNoEntry: false }
+        )) {
+          continue;
+        }
+        jobs++;
+      }
+      if (!jobs) return;
+      await (await this.getTarPool()).warm(jobs);
+    } catch {
+    }
+  }
   /**
    * A version's Brotli (`.tar.br`) alternate: its absolute URL, plus its
    * hash if the registry sent one. Returns undefined if the version has no
@@ -417,6 +462,15 @@ var PackageInfoClient = class {
     this.#storeLinker = linker && storeLinkers.has(linker) ? linker : "unpack";
   }
   async extract(spec, target, options = {}) {
+    const extractSpan = {};
+    try {
+      return await this.#extract(spec, target, options, extractSpan);
+    } catch (er) {
+      extractSpan.end?.({ how: "error" });
+      throw er;
+    }
+  }
+  async #extract(spec, target, options, extractSpan) {
     if (typeof spec === "string")
       spec = Spec.parse(spec, this.options);
     const {
@@ -434,6 +488,11 @@ var PackageInfoClient = class {
       spec,
       ...brotli && !integrity ? { digestRequired: true } : {}
     } : await this.resolve(spec, options);
+    const end = span("extract", {
+      spec: String(spec),
+      url: r.resolved
+    });
+    extractSpan.end = end;
     switch (f.type) {
       case "git": {
         const {
@@ -463,6 +522,7 @@ var PackageInfoClient = class {
             await clone(gitRemote, gitCommittish, target, { spec });
             void rm2(target + "/.git", { recursive: true });
           }
+          end({ how: "git" });
           return r;
         }
       }
@@ -491,6 +551,7 @@ var PackageInfoClient = class {
             this.#storeHits[how]++;
             logRequest(r.resolved, how === "copy" ? "cache" : "store");
             r.integrity ??= cachedIntegrity;
+            end({ how });
             return {
               ...r,
               manifest: index.manifest,
@@ -501,17 +562,23 @@ var PackageInfoClient = class {
           this.#storeMisses++;
         }
         const rc = await this.getRegistryClient();
-        const cached = rc.cachedBody(r.resolved, {
+        const cached = rc.cachedTarball(r.resolved, {
           integrity: r.integrity
         });
         if (cached) {
           try {
-            await pool.unpack(cached.body, target, format);
+            const unpacked = span("tarball:unpack", {
+              url: r.resolved,
+              bytes: cached.bytes
+            });
+            await pool.unpackCacheEntry(cached.path, target, format);
+            unpacked();
             logRequest(r.resolved, "cache");
             r.integrity ??= cached.integrity;
             if (storeOn || cached.gzip) {
               rc.queueForStore(cached.key, r.integrity);
             }
+            end({ how: "cache" });
             return r;
           } catch (er) {
             debug(
@@ -523,12 +590,17 @@ var PackageInfoClient = class {
         }
         const fetchTarball = async (useCache) => {
           const trustIntegrity = this.#trustedIntegrities.get(r.resolved) === r.integrity;
+          const fetched = span("tarball:fetch", { url: r.resolved });
           const response = await (await this.getRegistryClient()).request(r.resolved, {
             integrity: r.integrity,
             trustIntegrity,
             verifyDigest: r.digestRequired ? "required" : true,
             ...useCache === false ? { useCache } : {}
           });
+          fetched({
+            status: response.statusCode,
+            fromCache: response.fromCache
+          });
           if (response.statusCode !== 200) {
             throw this.#resolveError(
               spec,
@@ -581,7 +653,12 @@ var PackageInfoClient = class {
           }
         }
         try {
+          const unpacked = span("tarball:unpack", {
+            url: r.resolved,
+            bytes: buf.length
+          });
           await pool.unpack(buf, target, format);
+          unpacked();
         } catch (er) {
           throw this.#resolveError(
             spec,
@@ -590,11 +667,12 @@ var PackageInfoClient = class {
             { cause: er }
           );
         }
+        end({ how: "fetch", bytes: buf.length });
         return r;
       }
       case "remote": {
         const rc = await this.getRegistryClient();
-        const { CacheEntry: Entry, cacheKey } = await import("./src-A5ZJNOHN.js");
+        const { CacheEntry: Entry, cacheKey } = await import("./src-REZNPR2X.js");
         const key = cacheKey("GET", new URL(r.resolved));
         const unzipped = (entry) => {
           try {
@@ -668,6 +746,7 @@ var PackageInfoClient = class {
             { cause: er }
           );
         }
+        end({ how: "remote", bytes: buf.length });
         return r;
       }
       case "file": {
@@ -697,12 +776,14 @@ var PackageInfoClient = class {
             "file: specifier does not resolve to directory or tarball"
           );
         }
+        end({ how: "file" });
         return r;
       }
       case "workspace": {
         const ws = this.#getWS(spec, options);
         const rel = relative(dirname(target), ws.fullpath);
         await symlink(rel, target, "dir");
+        end({ how: "workspace" });
         return r;
       }
     }
@@ -1092,6 +1173,12 @@ var PackageInfoClient = class {
     return this.#resolvedManifests.size;
   }
   async manifest(spec, options = {}) {
+    const end = span("manifest", { spec: String(spec) });
+    const mani = await this.#manifest(spec, options);
+    end();
+    return mani;
+  }
+  async #manifest(spec, options) {
     const { from = this.#projectRoot } = options;
     if (typeof spec === "string")
       spec = Spec.parse(spec, this.options);

package/{chunk-ZJE3OTP3.js → chunk-6BD4RCTR.js}

@@ -51,25 +51,25 @@ import {
   shouldInstallDepType,
   symlinkSyncMkdirp,
   unshare
-} from "./chunk-C4RJ4NNS.js";
+} from "./chunk-TQBSL35R.js";
 import {
   SecurityArchive,
   usesNpmRegistry
-} from "./chunk-AHLBPSGQ.js";
+} from "./chunk-JASG7RHB.js";
 import {
   RollbackRemove,
   cmdShimIfExists,
   readCmdShimIfExists
-} from "./chunk-JV5XR5JQ.js";
+} from "./chunk-MCQTGFJY.js";
 import {
   detectLibc,
   getUser,
   platformCheck
-} from "./chunk-EMTGRCSE.js";
+} from "./chunk-GJMDZJPJ.js";
 import {
   Monorepo,
   PackageJson
-} from "./chunk-KURQHX54.js";
+} from "./chunk-6ISFYONV.js";
 import {
   baseDepID,
   getTuple,
@@ -88,16 +88,20 @@ import {
 } from "./chunk-HTOTG4TS.js";
 import {
   userAgent
-} from "./chunk-M242QVJS.js";
+} from "./chunk-HHSPE2DS.js";
 import {
   promiseSpawn
 } from "./chunk-SUU2WETN.js";
 import {
   graphStep
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";
+import {
+  mark,
+  trace
+} from "./chunk-6ETYWCJN.js";
 import {
   Spec,
   Version,
@@ -4670,6 +4674,12 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
   ];
   while (currentLevelDeps.length > 0) {
     const nextLevelDeps = [];
+    const depth = currentLevelDeps[0]?.depth ?? 0;
+    trace("build:level", {
+      from: fromNode.id,
+      depth,
+      entries: currentLevelDeps.length
+    });
     const fetchResults = await Promise.all(
       currentLevelDeps.map(
         async ({
@@ -4677,7 +4687,7 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
           deps: nodeDeps,
           modifierRefs: nodeModifierRefs,
           peerContext,
-          depth
+          depth: depth2
         }) => {
           const result = await fetchManifestsForDeps(
             packageInfo,
@@ -4692,7 +4702,7 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
             hydrations,
             peerContext,
             nodeModifierRefs,
-            depth,
+            depth2,
             explicit
           );
           return {
@@ -4701,13 +4711,14 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
               deps: nodeDeps,
               modifierRefs: nodeModifierRefs,
               peerContext,
-              depth
+              depth: depth2
             },
             result
           };
         }
       )
     );
+    trace("build:level:fetched", { from: fromNode.id, depth });
     const sortedResults = fetchResults.sort((a, b) => {
       const keyA = `${a.entry.node.id}::${a.entry.depth}`;
       const keyB = `${b.entry.node.id}::${b.entry.depth}`;
@@ -4764,6 +4775,11 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
         nextLevelDeps.push({ ...childDep, depth: nextDepth });
       }
     }
+    trace("build:level:placed", {
+      from: fromNode.id,
+      depth,
+      next: nextLevelDeps.length
+    });
     currentLevelDeps = nextLevelDeps;
   }
 };
@@ -4877,6 +4893,7 @@ var refreshIdealGraph = async ({
     node.setDefaultLocation();
   }
   if (extractPromises?.length) {
+    mark("build:extract-wait", { jobs: extractPromises.length });
     await Promise.all(extractPromises);
   }
 };
@@ -5604,6 +5621,8 @@ var reify = async (options) => {
     success = true;
     res.buildQueue = buildQueue;
   } finally {
+    await options.packageInfo.closeTarPool().catch(() => {
+    });
     if (!success) {
       await rollback(remover, diff, scurry).catch(() => {
       });
@@ -5617,6 +5636,7 @@ var reify_ = async (options, diff, remover, saveImportersPackageJson) => {
   const { packageInfo, packageJson, scurry, allowScripts } = options;
   const lfData = lockfileData(options);
   pruneUnsupportedOptional(diff);
+  void packageInfo.warmTarPool(diff.nodes.add);
   const actions = addNodes(
     diff,
     scurry,
@@ -5624,18 +5644,23 @@ var reify_ = async (options, diff, remover, saveImportersPackageJson) => {
     options,
     packageInfo
   ).concat(deleteEdges(diff, scurry, remover));
+  mark("reify:extract", { jobs: actions.length, limit });
   if (actions.length) await callLimit(actions, { limit });
   const edgeActions = addEdges(diff, scurry, remover);
+  mark("reify:edges", { jobs: edgeActions.length });
   if (edgeActions.length) await callLimit(edgeActions, { limit });
   const binActions = relinkBins(diff, scurry, remover);
   if (binActions.length) await callLimit(binActions, { limit });
+  mark("reify:hoist");
   await internalHoist(diff.to, options, remover);
   checkNeededBuild({ diff, scurry, packageJson });
   const allowScriptsNodes = await filterNodesByQuery(
     diff.to,
     allowScripts
   );
+  mark("reify:chmod");
   await binChmodAll(diff.nodes.add, scurry);
+  mark("reify:scripts");
   await build(diff, packageJson, scurry, allowScriptsNodes);
   res.buildQueue = [...diff.to.nodes.values()].filter((node) => node.buildState === "needed").map((node) => node.id);
   if (diff.hadOptionalFailures) {
@@ -5644,6 +5669,7 @@ var reify_ = async (options, diff, remover, saveImportersPackageJson) => {
       diff.nodes.delete.add(node);
     }
   }
+  mark("reify:lockfile");
   saveHidden(options);
   const rmActions = deleteNodes(
     diff,
@@ -5651,6 +5677,7 @@ var reify_ = async (options, diff, remover, saveImportersPackageJson) => {
     scurry,
     options.keepNodes
   );
+  mark("reify:delete", { jobs: rmActions.length });
   if (rmActions.length) await Promise.all(rmActions);
   saveImportersPackageJson?.();
   for (const node of diff.nodes.add) {
@@ -5765,7 +5792,7 @@ var uninstall = async (options, remove) => {
     throw err;
   }
   if (!allowSkills) return result;
-  const { linkSkills: linkSkills2 } = await import("./skills-7PYMTDER.js");
+  const { linkSkills: linkSkills2 } = await import("./skills-QOFA6XMM.js");
   result.skills = await linkSkills2({
     ...options,
     graph: result.graph,
@@ -5875,7 +5902,7 @@ var update = async (options) => {
     throw err;
   }
   if (!allowSkills) return result;
-  const { linkSkills: linkSkills2 } = await import("./skills-7PYMTDER.js");
+  const { linkSkills: linkSkills2 } = await import("./skills-QOFA6XMM.js");
   result.skills = await linkSkills2({
     ...options,
     graph: result.graph,
@@ -6219,7 +6246,7 @@ var install = async (options, add) => {
     throw err;
   }
   if (!allowSkills) return result;
-  const { linkSkills: linkSkills2 } = await import("./skills-7PYMTDER.js");
+  const { linkSkills: linkSkills2 } = await import("./skills-QOFA6XMM.js");
   result.skills = await linkSkills2({
     ...options,
     graph: result.graph,

package/{chunk-Y5PA7DVK.js → chunk-6ETYWCJN.js}

@@ -10,6 +10,197 @@ globalThis.clearInterval = _vlt_clearInterval;
 import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 
+// ../../src/output/src/trace.ts
+import { appendFileSync } from "node:fs";
+import { monitorEventLoopDelay, performance as performance2 } from "node:perf_hooks";
+import { threadId as ownThreadId } from "node:worker_threads";
+var sharedNow = () => performance2.timeOrigin + performance2.now();
+var defaultAppend = (file, data) => appendFileSync(file, data, { mode: 384 });
+var defaultWrite = (line) => process.stderr.write(line + "\n");
+var Tracer = class _Tracer {
+  enabled;
+  file;
+  phases;
+  #tid;
+  #now;
+  #append;
+  #write;
+  #flushLines;
+  #flushMs;
+  #buffer = [];
+  #timer;
+  #sampler;
+  #marks = [];
+  #start;
+  #loop;
+  #closed = false;
+  constructor(options = {}) {
+    this.file = options.file || void 0;
+    this.phases = !!options.phases;
+    this.enabled = !!this.file || this.phases;
+    this.#tid = options.threadId ?? ownThreadId;
+    this.#now = options.now ?? sharedNow;
+    this.#append = options.append ?? defaultAppend;
+    this.#write = options.write ?? defaultWrite;
+    this.#flushLines = options.flushLines ?? 200;
+    this.#flushMs = options.flushMs ?? 50;
+    this.#start = this.#now();
+    if (!this.enabled) return;
+    const main = options.main ?? this.#tid === 0;
+    if (main) {
+      this.#loop = monitorEventLoopDelay({ resolution: 20 });
+      this.#loop.enable();
+      const sampleMs = options.sampleMs ?? 20;
+      if (this.file && sampleMs > 0) {
+        this.#sampler = setInterval(() => this.sample(), sampleMs);
+        this.#sampler.unref();
+      }
+      process.once("exit", () => this.close());
+    }
+    this.trace("open", { pid: process.pid });
+  }
+  /**
+   * Build a tracer from the environment: `VLT_TRACE` names the file,
+   * `VLT_PHASES` (any value but `0` or empty) asks for the summary.
+   */
+  static fromEnv(env = process.env, options = {}) {
+    const phases = env.VLT_PHASES;
+    return new _Tracer({
+      ...options,
+      file: env.VLT_TRACE,
+      phases: !!phases && phases !== "0"
+    });
+  }
+  /** Record one event. */
+  trace(ev, fields) {
+    if (!this.file || this.#closed) return;
+    const event = { t: this.#now(), tid: this.#tid, ev };
+    if (fields) {
+      for (const [k2, v2] of Object.entries(fields)) {
+        if (v2 !== void 0) event[k2] = v2;
+      }
+    }
+    this.#buffer.push(JSON.stringify(event));
+    if (this.#buffer.length >= this.#flushLines) this.flush();
+    else if (!this.#timer) {
+      this.#timer = setTimeout(() => this.flush(), this.#flushMs);
+      this.#timer.unref();
+    }
+  }
+  /**
+   * Record a `<ev>:start` event now and return a function that records
+   * `<ev>:end` with the elapsed `ms` (plus any fields it is given). The
+   * same `fields` are stamped on both ends so the two can be paired.
+   */
+  span(ev, fields) {
+    if (!this.file) return noop;
+    const t0 = this.#now();
+    this.trace(`${ev}:start`, fields);
+    return (end) => this.trace(`${ev}:end`, {
+      ...fields,
+      ...end,
+      ms: Math.round((this.#now() - t0) * 1e3) / 1e3
+    });
+  }
+  /**
+   * Mark the start of a phase. The summary reports the ms between each
+   * mark and the next one, and the trace records a `phase` event.
+   */
+  mark(name, fields) {
+    if (!this.enabled) return;
+    this.#marks.push({ name, t: this.#now() });
+    this.trace("phase", { ...fields, name });
+  }
+  /**
+   * Record how busy a resource lane is: how many jobs it is running and
+   * how many are waiting for a slot. The report derives idle time per
+   * lane from these.
+   */
+  lane(name, busy, queued) {
+    if (!this.file) return;
+    this.trace("lane", { name, busy, queued });
+  }
+  /** Record a memory sample. */
+  sample() {
+    if (!this.file) return;
+    const m = process.memoryUsage();
+    this.trace("rss", {
+      rss: m.rss,
+      heap: m.heapUsed,
+      ext: m.external,
+      ab: m.arrayBuffers
+    });
+  }
+  /** Write buffered lines to the file. */
+  flush() {
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    if (!this.file || !this.#buffer.length) return;
+    const data = this.#buffer.join("\n") + "\n";
+    this.#buffer = [];
+    try {
+      this.#append(this.file, data);
+    } catch {
+    }
+  }
+  /**
+   * The one-line phase summary, or undefined when phases are off. Each
+   * phase is reported as the ms from its mark to the next mark (or to
+   * now, for the last one).
+   */
+  summary() {
+    if (!this.phases) return void 0;
+    const now = this.#now();
+    const parts = [];
+    for (const [i, m] of this.#marks.entries()) {
+      const next = this.#marks[i + 1]?.t ?? now;
+      parts.push(`${m.name}=${Math.round(next - m.t)}`);
+    }
+    parts.push(`total=${Math.round(now - this.#start)}`);
+    if (this.#loop) {
+      const ms2 = (n7) => Math.round(n7 / 1e6);
+      parts.push(
+        `loop p50=${ms2(this.#loop.percentile(50))} p99=${ms2(this.#loop.percentile(99))} max=${ms2(this.#loop.max)}`
+      );
+    }
+    const { maxRSS } = process.resourceUsage();
+    parts.push(`maxrss=${Math.round(maxRSS / 1024)}MB`);
+    return `PHASES ${parts.join(" ")}`;
+  }
+  /**
+   * Stop sampling, flush, and print the summary. Runs at process exit
+   * on the main thread; safe to call more than once.
+   */
+  close() {
+    if (this.#closed) return;
+    if (this.#sampler) clearInterval(this.#sampler);
+    if (this.enabled) {
+      if (this.#loop) {
+        this.#loop.disable();
+        this.trace("exit", {
+          loopP50: Math.round(this.#loop.percentile(50) / 1e6),
+          loopP99: Math.round(this.#loop.percentile(99) / 1e6),
+          loopMax: Math.round(this.#loop.max / 1e6),
+          maxrss: process.resourceUsage().maxRSS
+        });
+      }
+      const line = this.summary();
+      this.flush();
+      if (line) this.#write(line);
+    }
+    this.#closed = true;
+  }
+};
+var noop = () => {
+};
+var tracer = Tracer.fromEnv();
+var trace = (ev, fields) => tracer.trace(ev, fields);
+var span = (ev, fields) => tracer.span(ev, fields);
+var mark = (name, fields) => tracer.mark(name, fields);
+var lane = (name, busy, queued) => tracer.lane(name, busy, queued);
+
 // ../../node_modules/.vlt/~npm~glob@13.0.6/node_modules/glob/dist/esm/index.min.js
 import { fileURLToPath as Wi } from "node:url";
 import { posix as mi, win32 as re } from "node:path";
@@ -2997,5 +3188,10 @@ Ze.glob = Ze;
 export {
   ot,
   ts,
-  Ze
+  Ze,
+  tracer,
+  trace,
+  span,
+  mark,
+  lane
 };

package/{chunk-KURQHX54.js → chunk-6ISFYONV.js}

@@ -22,11 +22,11 @@ import {
 } from "./chunk-HTOTG4TS.js";
 import {
   I
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   ot,
   ts
-} from "./chunk-Y5PA7DVK.js";
+} from "./chunk-6ETYWCJN.js";
 import {
   asManifest,
   longDependencyTypes,

package/{chunk-VGPLFOJO.js → chunk-AQJR7QDA.js}

@@ -13,7 +13,7 @@ import {
   defaultRegistryKey,
   getTokenByURL,
   registryKeys
-} from "./chunk-Q2UEILN6.js";
+} from "./chunk-NB7QVWHU.js";
 
 // ../../src/cli-sdk/src/query-auth.ts
 var createGetAuthHeader = (conf) => {

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

@@ -15,7 +15,7 @@ import {
 } from "./chunk-SRWDPPLX.js";
 import {
   minimatch
-} from "./chunk-KURQHX54.js";
+} from "./chunk-6ISFYONV.js";
 import {
   Spec
 } from "./chunk-6D3QAFNZ.js";