vlt 1.6.0 → 1.6.2

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-TQQO2F56.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,
@@ -115,6 +115,7 @@ var PackageJson = class {
       writeFileSync(filename, stringify(manifest, void 0, indent));
       this.#cache.set(dir, manifest);
       this.#pathCache.set(manifest, dir);
+      this.#errCache.delete(dir);
     } catch (err) {
       this.#cache.delete(dir);
       this.#pathCache.delete(manifest);

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

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

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

@@ -15,7 +15,7 @@ import {
 } from "./chunk-SRWDPPLX.js";
 import {
   minimatch
-} from "./chunk-TQQO2F56.js";
+} from "./chunk-6ISFYONV.js";
 import {
   Spec
 } from "./chunk-6D3QAFNZ.js";
@@ -1865,7 +1865,12 @@ var require_ignore = __commonJS({
 // ../../src/cli-sdk/src/pack-tarball.ts
 var ssri = __toESM(require_lib(), 1);
 import assert from "node:assert";
-import { existsSync, readFileSync, statSync } from "node:fs";
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  statSync
+} from "node:fs";
 import { join } from "node:path";
 var import_ignore = __toESM(require_ignore(), 1);
 var replaceWorkspaceAndCatalogSpecs = (manifest_, config) => {
@@ -2004,7 +2009,16 @@ var buildPackFilter = (manifest, packDir) => {
       }
     }
   }
-  return (path) => {
+  const files = (manifestWithFiles.files ?? []).map((pattern) => pattern.replace(/^\.?\//, "").replace(/\/+$/, "")).filter(Boolean);
+  const isReadableDir = (dir) => {
+    try {
+      readdirSync(join(packDir, dir));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return (path, entry) => {
     const normalizedPath = path.replace(/^\.\//, "");
     if (path === "." || normalizedPath === "") {
       return true;
@@ -2025,30 +2039,16 @@ var buildPackFilter = (manifest, packDir) => {
     if (hasEmptyFilesField) {
       return false;
     }
-    if (hasFilesField && manifestWithFiles.files) {
-      return manifestWithFiles.files.some((pattern) => {
-        if (pattern.endsWith("/")) {
-          const dirName = pattern.slice(0, -1);
-          const globPattern = pattern.replace(/\/$/, "/**");
-          const matchesDir = normalizedPath === dirName;
-          const matchesContents = minimatch(
-            normalizedPath,
-            globPattern,
-            { dot: true }
-          );
-          return matchesDir || matchesContents;
-        }
-        const directMatch = minimatch(normalizedPath, pattern, {
-          dot: true
-        });
-        const isParentDir = pattern.includes("/") && pattern.startsWith(normalizedPath + "/");
-        const isChildOfPattern = minimatch(
-          normalizedPath,
-          pattern + "/**",
-          { dot: true }
-        );
-        return directMatch || isParentDir || isChildOfPattern;
-      });
+    if (hasFilesField) {
+      const isDir = "isDirectory" in entry && entry.isDirectory();
+      return files.some(
+        (pattern) => minimatch(normalizedPath, pattern, { dot: true }) || minimatch(normalizedPath, `${pattern}/**`, { dot: true })
+      ) || isDir && files.some(
+        (pattern) => minimatch(normalizedPath, pattern, {
+          dot: true,
+          partial: true
+        })
+      ) && isReadableDir(normalizedPath);
     }
     if (ig?.ignores(normalizedPath)) {
       return false;

package/{chunk-KVWGMSPW.js → chunk-C75GDQFE.js}

@@ -42,10 +42,13 @@ import {
 } from "./chunk-CAV7FKWQ.js";
 import {
   emitter
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";
+import {
+  mark
+} from "./chunk-6ETYWCJN.js";
 import {
   isErrorWithCause,
   isObject
@@ -326,7 +329,15 @@ var getClient = () => {
       // Buffer up to 20 events and flush every 10 s — but we always
       // call shutdown at the end so this is just a safety net.
       flushAt: 20,
-      flushInterval: 1e4
+      flushInterval: 1e4,
+      // one attempt, capped like flush(); failed sends resolve as 204
+      // so offline or erroring runs neither wait nor log
+      fetchRetryCount: 0,
+      requestTimeout: SHUTDOWN_TIMEOUT_MS,
+      fetch: async (url, init) => {
+        const res = await fetch(url, init).catch(() => void 0);
+        return res?.ok ? res : new Response(null, { status: 204 });
+      }
     });
     return _posthog;
   } catch {
@@ -693,7 +704,10 @@ var outputCommand = async (cliCommand, conf, { start, vltVersion } = {
       );
     }
     if (conf.globalRoot) await sweepPendingRemove(conf.globalRoot);
-    const output = await onDone(await command(conf));
+    const result = await command(conf);
+    mark("command:done");
+    const output = await onDone(result);
+    mark("view:done");
     stopRequestLog();
     const duration_ms = Date.now() - start;
     trackCommand(
@@ -721,6 +735,7 @@ var outputCommand = async (cliCommand, conf, { start, vltVersion } = {
       );
     }
     await flush();
+    mark("telemetry:flushed");
   } catch (err) {
     stopRequestLog();
     onError?.(err);

package/{chunk-TWDSXQPN.js → chunk-FRX5IFFY.js}

@@ -11,18 +11,18 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   install
-} from "./chunk-36UIE654.js";
+} from "./chunk-6BD4RCTR.js";
 import {
   PackageInfoClient
-} from "./chunk-LCLRP64K.js";
+} from "./chunk-3UDBYFAH.js";
 import {
   RollbackRemove,
   cmdShim,
   findCmdShimIfExists
-} from "./chunk-JV5XR5JQ.js";
+} from "./chunk-MCQTGFJY.js";
 import {
   PathScurry
-} from "./chunk-TQQO2F56.js";
+} from "./chunk-6ISFYONV.js";
 import {
   Spec
 } from "./chunk-6D3QAFNZ.js";

package/{chunk-DBANBIL2.js → chunk-FZCPQWCJ.js}

@@ -203,6 +203,7 @@ var del = (object, path) => {
     assertNotStringIndex(object, key);
     if (isLast(pathArray, index)) {
       if (Array.isArray(object)) {
+        if (typeof key !== "number") return false;
         object.splice(key, 1);
       } else {
         delete object[key];

package/{chunk-EMTGRCSE.js → chunk-GJMDZJPJ.js}

@@ -18,7 +18,7 @@ import {
 } from "./chunk-SUU2WETN.js";
 import {
   I
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   Range,
   Version,

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

package/{chunk-YTDABXPD.js → chunk-JASG7RHB.js}

@@ -16,10 +16,10 @@ import {
 } from "./chunk-CAV7FKWQ.js";
 import {
   userAgent
-} from "./chunk-GEQFMH5M.js";
+} from "./chunk-HHSPE2DS.js";
 import {
   I
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";

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

@@ -12,13 +12,13 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   actual,
   createVirtualRoot
-} from "./chunk-36UIE654.js";
+} from "./chunk-6BD4RCTR.js";
 import {
   callLimit
-} from "./chunk-F5LZMLAQ.js";
+} from "./chunk-TQBSL35R.js";
 import {
   SecurityArchive
-} from "./chunk-YTDABXPD.js";
+} from "./chunk-JASG7RHB.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";
@@ -142,7 +142,7 @@ var reloadConfig = async (folder) => {
     unload("project");
   } catch {
   }
-  const { Config } = await import("./config-EKHBW6I5.js");
+  const { Config } = await import("./config-C73FLGQV.js");
   return Config.load(folder, process.argv, true, false);
 };
 

package/{chunk-ANW36H4T.js → chunk-JYYIWXJX.js}

@@ -15,7 +15,7 @@ import {
   pairsToRecords,
   registrySelectionFields,
   registrySelectors
-} from "./chunk-LP3ORD3D.js";
+} from "./chunk-3RYVF2GG.js";
 import {
   normalizeRegistryURL
 } from "./chunk-7M2VTFLP.js";

package/{chunk-22LZBDEC.js → chunk-L65CG5LE.js}

@@ -11,7 +11,7 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   stderr
-} from "./chunk-KVWGMSPW.js";
+} from "./chunk-C75GDQFE.js";
 import {
   urlOpen
 } from "./chunk-QNHBAGXQ.js";

package/{chunk-PDWPFR5T.js → chunk-LEMHGORE.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   Ze,
   ts
-} from "./chunk-Y5PA7DVK.js";
+} from "./chunk-6ETYWCJN.js";
 
 // ../../node_modules/.vlt/~npm~rimraf@6.1.3/node_modules/rimraf/dist/esm/opt-arg.js
 var typeOrUndef = (val, t) => typeof val === "undefined" || typeof val === t;

package/{chunk-JV5XR5JQ.js → chunk-MCQTGFJY.js}

@@ -11,7 +11,7 @@ import {createRequire as _vlt_createRequire} from "node:module";
 var require = _vlt_createRequire(import.meta.filename);
 import {
   rimraf
-} from "./chunk-PDWPFR5T.js";
+} from "./chunk-LEMHGORE.js";
 import {
   error
 } from "./chunk-WZWDS3W4.js";

package/{chunk-O6MQ7NN6.js → chunk-N4SU52H5.js}

@@ -21,7 +21,7 @@ import {
   RollbackRemove,
   cmdShimIfExists,
   findCmdShimIfExists
-} from "./chunk-JV5XR5JQ.js";
+} from "./chunk-MCQTGFJY.js";
 import {
   readGlobalState,
   updateGlobalState,

package/{chunk-44AWMA4F.js → chunk-NB7QVWHU.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-QNHBAGXQ.js";
 import {
   userAgent
-} from "./chunk-GEQFMH5M.js";
+} from "./chunk-HHSPE2DS.js";
 import {
   assertOk,
   registryErrorMessage,
@@ -25,13 +25,13 @@ import {
 import {
   I,
   logRequest
-} from "./chunk-B6RIGNEO.js";
+} from "./chunk-ZESNN24A.js";
 import {
   XDG
 } from "./chunk-XNLSTHDK.js";
 import {
   rimraf
-} from "./chunk-PDWPFR5T.js";
+} from "./chunk-LEMHGORE.js";
 import {
   asError,
   integrityHex,
@@ -26150,7 +26150,13 @@ var handleBeforeExit = () => {
 // ../../src/registry-client/src/index.ts
 var import_undici3 = __toESM(require_undici(), 1);
 import { randomUUID } from "node:crypto";
-import { closeSync, openSync, readFileSync as readFileSync2, readSync } from "node:fs";
+import {
+  closeSync,
+  fstatSync,
+  openSync,
+  readFileSync as readFileSync2,
+  readSync
+} from "node:fs";
 import { availableParallelism } from "node:os";
 import { dirname as dirname3, resolve as resolve4 } from "node:path";
 import { setMaxListeners } from "node:events";
@@ -27959,18 +27965,9 @@ var RegistryClient = class {
   cachedBody(url, options = {}) {
     const { integrity, method = "GET" } = options;
     try {
-      const key = cacheKey(
-        method,
-        typeof url === "string" ? new URL(url) : url
-      );
-      if (this.cache.peek(key)) return void 0;
-      const paths = /* @__PURE__ */ new Set();
-      try {
-        const i = this.cache.integrityPath(integrity);
-        if (i) paths.add(i);
-      } catch {
-      }
-      if (!integrity) paths.add(this.cache.path(key));
+      const found = this.#cachedPaths(url, method, integrity);
+      if (!found) return void 0;
+      const { key, paths } = found;
       for (const path of paths) {
         let buf;
         try {
@@ -27994,6 +27991,77 @@ var RegistryClient = class {
     }
     return void 0;
   }
+  /**
+   * Find a valid cached non-JSON body on disk without reading it: only
+   * the head is read, to check the entry. Bypasses the in-memory cache
+   * LRU like {@link cachedBody}.
+   *
+   * The body's offset is not returned. `cache-unzip` can rewrite the
+   * entry, and its head, before the body is read, so whoever reads the
+   * body takes the head length from the same bytes (see `@vltpkg/tar`'s
+   * `unpackCacheEntry`). A rewrite keeps the same tarball, un-gzipped.
+   *
+   * Does not log a cache hit. Returns undefined on anything unexpected;
+   * callers fall back to {@link request}.
+   */
+  cachedTarball(url, options = {}) {
+    const { integrity, method = "GET" } = options;
+    try {
+      const found = this.#cachedPaths(url, method, integrity);
+      if (!found) return void 0;
+      const { key, paths } = found;
+      for (const path of paths) {
+        let fd;
+        try {
+          fd = openSync(path, "r");
+        } catch {
+          continue;
+        }
+        try {
+          const size = Buffer.allocUnsafe(4);
+          if (readSync(fd, size, 0, 4, 0) < 4) continue;
+          const headSize = size.readUInt32BE(0);
+          if (headSize < 7 || headSize > maxHeadSize) continue;
+          const head = Buffer.allocUnsafe(headSize + 2);
+          const read = readSync(fd, head, 0, headSize + 2, 0);
+          if (read < headSize) continue;
+          const entry = CacheEntry.decodeHead(head.subarray(0, read));
+          if (entry.statusCode !== 200 || !entry.valid || entry.isJSON) {
+            continue;
+          }
+          return {
+            path,
+            key,
+            bytes: fstatSync(fd).size - headSize,
+            integrity: entry.integrity,
+            gzip: CacheEntry.isGzipEntry(head.subarray(0, read))
+          };
+        } finally {
+          closeSync(fd);
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  // The cache files that may hold a body for `url`, or undefined when
+  // the in-memory cache should answer instead. Shared by cachedBody and
+  // cachedTarball.
+  #cachedPaths(url, method, integrity) {
+    const key = cacheKey(
+      method,
+      typeof url === "string" ? new URL(url) : url
+    );
+    if (this.cache.peek(key)) return void 0;
+    const paths = /* @__PURE__ */ new Set();
+    try {
+      const i = this.cache.integrityPath(integrity);
+      if (i) paths.add(i);
+    } catch {
+    }
+    if (!integrity) paths.add(this.cache.path(key));
+    return { key, paths };
+  }
   /**
    * Queue the cached tarball at `key` (a {@link CachedBody} key) for the
    * background child: exploded into the global store when that is on,