vlt 1.6.1 → 1.6.2

package/registry-client-src-revalidate.js

@@ -1056,7 +1056,7 @@ var require_util = __commonJS({
         yield* this[kBody];
       }
     };
-    function noop() {
+    function noop2() {
     }
     function wrapRequestBody(body) {
       if (isStream(body)) {
@@ -1722,7 +1722,7 @@ var require_util = __commonJS({
     }
     var setupConnectTimeout = process.platform === "win32" ? (socketWeakRef, opts) => {
       if (!opts.timeout) {
-        return noop;
+        return noop2;
       }
       let s1 = null;
       let s2 = null;
@@ -1738,7 +1738,7 @@ var require_util = __commonJS({
       };
     } : (socketWeakRef, opts) => {
       if (!opts.timeout) {
-        return noop;
+        return noop2;
       }
       let s1 = null;
       const fastTimer = timers.setFastTimeout(() => {
@@ -5026,7 +5026,7 @@ var require_util2 = __commonJS({
     var { redirectStatusSet, referrerPolicyTokens, badPortsSet } = require_constants3();
     var { getGlobalOrigin } = require_global();
     var { collectAnHTTPQuotedString, parseMIMEType } = require_data_url();
-    var { performance: performance2 } = __require("node:perf_hooks");
+    var { performance: performance3 } = __require("node:perf_hooks");
     var { ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util();
     var assert = __require("node:assert");
     var { isUint8Array } = __require("node:util/types");
@@ -5181,7 +5181,7 @@ var require_util2 = __commonJS({
       };
     }
     function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) {
-      return coarsenTime(performance2.now(), crossOriginIsolatedCapability);
+      return coarsenTime(performance3.now(), crossOriginIsolatedCapability);
     }
     function createOpaqueTimingInfo(timingInfo) {
       return {
@@ -6319,12 +6319,12 @@ var require_body = __commonJS({
     var { runtimeFeatures } = require_runtime_features();
     var random = runtimeFeatures.has("crypto") ? __require("node:crypto").randomInt : (max) => Math.floor(Math.random() * max);
     var textEncoder = new TextEncoder();
-    function noop() {
+    function noop2() {
     }
     var streamRegistry = new FinalizationRegistry((weakRef) => {
       const stream = weakRef.deref();
       if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
-        stream.cancel("Response object has been garbage collected").catch(noop);
+        stream.cancel("Response object has been garbage collected").catch(noop2);
       }
     });
     function extractBody(object, keepalive = false) {
@@ -8641,7 +8641,7 @@ var require_client = __commonJS({
     var getDefaultNodeMaxHeaderSize = http && http.maxHeaderSize && Number.isInteger(http.maxHeaderSize) && http.maxHeaderSize > 0 ? () => http.maxHeaderSize : () => {
       throw new InvalidArgumentError("http module not available or http.maxHeaderSize invalid");
     };
-    var noop = () => {
+    var noop2 = () => {
     };
     function getPipelining(client) {
       return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
@@ -8943,7 +8943,7 @@ var require_client = __commonJS({
             return;
           }
           if (client.destroyed) {
-            util.destroy(socket.on("error", noop), new ClientDestroyedError());
+            util.destroy(socket.on("error", noop2), new ClientDestroyedError());
             client[kResume]();
             return;
           }
@@ -8951,7 +8951,7 @@ var require_client = __commonJS({
           try {
             client[kHTTPContext] = socket.alpnProtocol === "h2" ? connectH2(client, socket) : connectH1(client, socket);
           } catch (err2) {
-            socket.destroy().on("error", noop);
+            socket.destroy().on("error", noop2);
             handleConnectError(client, err2, { host, hostname, protocol, port });
             client[kResume]();
             return;
@@ -10571,7 +10571,7 @@ var require_proxy_agent = __commonJS({
     function defaultFactory(origin, opts) {
       return new Pool(origin, opts);
     }
-    var noop = () => {
+    var noop2 = () => {
     };
     function defaultAgentFactory(origin, opts) {
       if (opts.connections === 1) {
@@ -10708,7 +10708,7 @@ var require_proxy_agent = __commonJS({
               };
               const { socket, statusCode } = await this[kClient].connect(connectParams);
               if (statusCode !== 200) {
-                socket.on("error", noop).destroy();
+                socket.on("error", noop2).destroy();
                 callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`));
                 return;
               }
@@ -11348,7 +11348,7 @@ var require_readable = __commonJS({
     var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
     var kUsed = /* @__PURE__ */ Symbol("kUsed");
     var kBytesRead = /* @__PURE__ */ Symbol("kBytesRead");
-    var noop = () => {
+    var noop2 = () => {
     };
     var BodyReadable = class extends Readable {
       /**
@@ -11573,7 +11573,7 @@ var require_readable = __commonJS({
           } else {
             this.on("close", resolve11);
           }
-          this.on("error", noop).on("data", () => {
+          this.on("error", noop2).on("data", () => {
             if (this[kBytesRead] > limit) {
               this.destroy();
             }
@@ -11742,7 +11742,7 @@ var require_api_request = __commonJS({
     var { Readable } = require_readable();
     var { InvalidArgumentError, RequestAbortedError } = require_errors();
     var util = require_util();
-    function noop() {
+    function noop2() {
     }
     var RequestHandler = class extends AsyncResource {
       constructor(opts, callback) {
@@ -11769,7 +11769,7 @@ var require_api_request = __commonJS({
           super("UNDICI_REQUEST");
         } catch (err) {
           if (util.isStream(body)) {
-            util.destroy(body.on("error", noop), err);
+            util.destroy(body.on("error", noop2), err);
           }
           throw err;
         }
@@ -11792,7 +11792,7 @@ var require_api_request = __commonJS({
           this.removeAbortListener = util.addAbortListener(signal, () => {
             this.reason = signal.reason ?? new RequestAbortedError();
             if (this.res) {
-              util.destroy(this.res.on("error", noop), this.reason);
+              util.destroy(this.res.on("error", noop2), this.reason);
             } else if (this.abort) {
               this.abort(this.reason);
             }
@@ -11846,7 +11846,7 @@ var require_api_request = __commonJS({
             });
           } catch (err) {
             this.res = null;
-            util.destroy(res.on("error", noop), err);
+            util.destroy(res.on("error", noop2), err);
             queueMicrotask(() => {
               throw err;
             });
@@ -11871,13 +11871,13 @@ var require_api_request = __commonJS({
         if (res) {
           this.res = null;
           queueMicrotask(() => {
-            util.destroy(res.on("error", noop), err);
+            util.destroy(res.on("error", noop2), err);
           });
         }
         if (body) {
           this.body = null;
           if (util.isStream(body)) {
-            body.on("error", noop);
+            body.on("error", noop2);
             util.destroy(body, err);
           }
         }
@@ -11973,7 +11973,7 @@ var require_api_stream = __commonJS({
     var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
     var util = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
-    function noop() {
+    function noop2() {
     }
     var StreamHandler = class extends AsyncResource {
       constructor(opts, factory, callback) {
@@ -12000,7 +12000,7 @@ var require_api_stream = __commonJS({
           super("UNDICI_STREAM");
         } catch (err) {
           if (util.isStream(body)) {
-            util.destroy(body.on("error", noop), err);
+            util.destroy(body.on("error", noop2), err);
           }
           throw err;
         }
@@ -12142,7 +12142,7 @@ var require_api_pipeline = __commonJS({
     } = require_errors();
     var util = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
-    function noop() {
+    function noop2() {
     }
     var kResume = /* @__PURE__ */ Symbol("resume");
     var PipelineRequest = class extends Readable {
@@ -12202,7 +12202,7 @@ var require_api_pipeline = __commonJS({
         this.abort = null;
         this.context = null;
         this.onInfo = onInfo || null;
-        this.req = new PipelineRequest().on("error", noop);
+        this.req = new PipelineRequest().on("error", noop2);
         this.ret = new Duplex({
           readableObjectMode: opts.objectMode,
           autoDestroy: true,
@@ -12273,7 +12273,7 @@ var require_api_pipeline = __commonJS({
             context
           });
         } catch (err) {
-          this.res.on("error", noop);
+          this.res.on("error", noop2);
           throw err;
         }
         if (!body || typeof body.on !== "function") {
@@ -14543,7 +14543,7 @@ var require_redirect_handler = __commonJS({
     var EE = __require("node:events");
     var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
     var kBody = /* @__PURE__ */ Symbol("body");
-    var noop = () => {
+    var noop2 = () => {
     };
     var BodyAsyncIterable = class {
       constructor(body) {
@@ -14606,14 +14606,14 @@ var require_redirect_handler = __commonJS({
         if ((statusCode === 301 || statusCode === 302) && this.opts.method === "POST") {
           this.opts.method = "GET";
           if (util.isStream(this.opts.body)) {
-            util.destroy(this.opts.body.on("error", noop));
+            util.destroy(this.opts.body.on("error", noop2));
           }
           this.opts.body = null;
         }
         if (statusCode === 303 && this.opts.method !== "HEAD") {
           this.opts.method = "GET";
           if (util.isStream(this.opts.body)) {
-            util.destroy(this.opts.body.on("error", noop));
+            util.destroy(this.opts.body.on("error", noop2));
           }
           this.opts.body = null;
         }
@@ -16344,7 +16344,7 @@ var require_cache_handler = __commonJS({
       isEtagUsable
     } = require_cache();
     var { parseHttpDate } = require_date();
-    function noop() {
+    function noop2() {
     }
     var HEURISTICALLY_CACHEABLE_STATUS_CODES = [
       200,
@@ -16661,7 +16661,7 @@ var require_cache_handler = __commonJS({
     };
     function deleteCachedValue(store, cacheKey2) {
       try {
-        store.delete(cacheKey2)?.catch?.(noop);
+        store.delete(cacheKey2)?.catch?.(noop2);
       } catch {
       }
     }
@@ -32153,6 +32153,195 @@ var handleBeforeExit = () => {
 
 // ../../src/output/src/index.ts
 import EventEmitter from "node:events";
+
+// ../../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 main2 = options.main ?? this.#tid === 0;
+    if (main2) {
+      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 [k4, v3] of Object.entries(fields)) {
+        if (v3 !== void 0) event[k4] = v3;
+      }
+    }
+    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 m2 = process.memoryUsage();
+    this.trace("rss", {
+      rss: m2.rss,
+      heap: m2.heapUsed,
+      ext: m2.external,
+      ab: m2.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 [i2, m2] of this.#marks.entries()) {
+      const next = this.#marks[i2 + 1]?.t ?? now;
+      parts.push(`${m2.name}=${Math.round(next - m2.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();
+
+// ../../src/output/src/index.ts
 var OutputEmitter = class {
   emitter = new EventEmitter();
   emit(eventName, payload) {
@@ -32168,6 +32357,9 @@ var OutputEmitter = class {
 var emitter = new OutputEmitter();
 var logRequest = (url, state, details = {}) => {
   emitter.emit("request", { url, state, ...details });
+  if (tracer.file) {
+    tracer.trace("request", { ...details, url: String(url), state });
+  }
 };
 
 // ../../src/promise-spawn/src/index.ts
@@ -32520,7 +32712,13 @@ var XDG = class {
 // ../../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 resolve10 } from "node:path";
 import { setMaxListeners } from "node:events";
@@ -32532,7 +32730,7 @@ import { createGunzip } from "node:zlib";
 var package_default = {
   name: "@vltpkg/user-agent",
   description: "The User-Agent string that vlt sends with every outbound request",
-  version: "1.6.1",
+  version: "1.6.2",
   repository: {
     type: "git",
     url: "git+https://github.com/vltpkg/vltpkg.git",
@@ -34344,18 +34542,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 i2 = this.cache.integrityPath(integrity);
-        if (i2) paths.add(i2);
-      } 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 path2 of paths) {
         let buf;
         try {
@@ -34379,6 +34568,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 path2 of paths) {
+        let fd;
+        try {
+          fd = openSync(path2, "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: path2,
+            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 i2 = this.cache.integrityPath(integrity);
+      if (i2) paths.add(i2);
+    } 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,

package/{repo-VLHLQP2S.js → repo-BYOSXG5J.js}

@@ -14,20 +14,20 @@ import {
 } from "./chunk-CLVRCGOZ.js";
 import {
   openUrl
-} from "./chunk-5Q2HSLVV.js";
+} from "./chunk-L65CG5LE.js";
 import {
   createHostContextsMap
-} from "./chunk-W24SBFY5.js";
+} from "./chunk-JNPVOACH.js";
 import {
   actual
-} from "./chunk-ZJE3OTP3.js";
+} from "./chunk-6BD4RCTR.js";
 import {
   Query
-} from "./chunk-C4RJ4NNS.js";
+} from "./chunk-TQBSL35R.js";
 import {
   SecurityArchive
-} from "./chunk-AHLBPSGQ.js";
-import "./chunk-MSWOR3FV.js";
+} from "./chunk-JASG7RHB.js";
+import "./chunk-C75GDQFE.js";
 import "./chunk-LGQVZTYR.js";
 import "./chunk-EYGOEAJM.js";
 import {
@@ -35,11 +35,11 @@ import {
 } from "./chunk-HT6FS4VB.js";
 import {
   PackageInfoClient
-} from "./chunk-IHERL3TA.js";
+} from "./chunk-3UDBYFAH.js";
 import "./chunk-SRWDPPLX.js";
-import "./chunk-JV5XR5JQ.js";
-import "./chunk-EMTGRCSE.js";
-import "./chunk-KURQHX54.js";
+import "./chunk-MCQTGFJY.js";
+import "./chunk-GJMDZJPJ.js";
+import "./chunk-6ISFYONV.js";
 import "./chunk-4KCU2KZL.js";
 import "./chunk-WGDTG44V.js";
 import "./chunk-E74WGW5C.js";
@@ -53,13 +53,14 @@ import {
 } from "./chunk-6D3QAFNZ.js";
 import "./chunk-HTOTG4TS.js";
 import "./chunk-QNHBAGXQ.js";
-import "./chunk-M242QVJS.js";
+import "./chunk-HHSPE2DS.js";
 import "./chunk-4GMNWW4C.js";
 import "./chunk-SUU2WETN.js";
-import "./chunk-B6RIGNEO.js";
+import "./chunk-ZESNN24A.js";
 import "./chunk-XNLSTHDK.js";
-import "./chunk-PDWPFR5T.js";
-import "./chunk-Y5PA7DVK.js";
+import "./chunk-24DWRCPS.js";
+import "./chunk-LEMHGORE.js";
+import "./chunk-6ETYWCJN.js";
 import "./chunk-BF5DRGRZ.js";
 import {
   error