vlt 1.6.1 → 1.6.2

package/src-GY57R4DK.js

@@ -0,0 +1,659 @@
+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 {
+  cacheEntryBody,
+  markStoreEntryCopied,
+  removeStoreEntry,
+  storeCopiedPath,
+  storeEntryCopied,
+  storeEntryLastCopied,
+  storeEntryLinked,
+  storeEntryNames,
+  storeEntryTime,
+  tmpName,
+  unpack,
+  unpackCacheEntryParallel,
+  unpackCacheEntrySync,
+  unpackFileParallel,
+  unpackFileSync,
+  unpackParallel,
+  unpackSync,
+  unpackToStoreSync,
+  verifyStoreEntry
+} from "./chunk-QFPAFVRR.js";
+import {
+  cloneAvailable,
+  cloneDir
+} from "./chunk-6IF3RJND.js";
+import {
+  readStoreIndex,
+  storeIndexPath
+} from "./chunk-24DWRCPS.js";
+import {
+  rimrafSync
+} from "./chunk-LEMHGORE.js";
+import {
+  lane,
+  trace
+} from "./chunk-6ETYWCJN.js";
+import "./chunk-BF5DRGRZ.js";
+import "./chunk-WZWDS3W4.js";
+import "./chunk-PZLD7RTK.js";
+
+// ../../src/tar/src/link-tree.ts
+import {
+  chmodSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, sep } from "node:path";
+import { debuglog } from "node:util";
+var debug = debuglog("vlt");
+var noThrow = { throwIfNoEntry: false };
+var verify = process.env.VLT_STORE_VERIFY === "1";
+var copyAll = false;
+var downgrade = (code) => {
+  copyAll = true;
+  debug("global store: linking failed, copying from now on", code);
+};
+var cloneNone = false;
+var native = (p) => sep === "/" ? p : p.replaceAll("/", sep);
+var cloneEntry = (storeEntry, tmp) => {
+  const res = cloneDir(storeEntry, tmp);
+  if (res === true) return true;
+  if (res === "ENOTSUP" || res === "EXDEV" || res === "EPERM" || res === "EACCES") {
+    cloneNone = true;
+    debug("global store: cloning failed, unpacking from now on", res);
+  }
+  return false;
+};
+var checkClone = (tmp, index) => {
+  const counts = /* @__PURE__ */ new Map([["", 0]]);
+  for (const d of index.dirs) counts.set(d, 0);
+  for (const p of [...index.dirs, ...index.files.map((f) => f[0])]) {
+    const i = p.lastIndexOf("/");
+    const d = i === -1 ? "" : p.slice(0, i);
+    const n = counts.get(d);
+    if (n === void 0) return "damaged";
+    counts.set(d, n + 1);
+  }
+  for (const [d, n] of counts) {
+    let names;
+    try {
+      names = readdirSync(d ? tmp + sep + native(d) : tmp);
+    } catch {
+      return "damaged";
+    }
+    if (names.length !== n) return "damaged";
+  }
+  const pj = index.files.find((f) => f[0] === "package.json");
+  if (verify && pj && statSync(tmp + sep + "package.json").size !== pj[1]) {
+    return "damaged";
+  }
+};
+var place = (src, dst, exec, copy) => {
+  if (!copy && !copyAll) {
+    try {
+      linkSync(src, dst);
+      return "link";
+    } catch (er) {
+      const { code = "" } = er;
+      if (code === "ENOENT") {
+        if (!lstatSync(src, noThrow)) return false;
+        if (!lstatSync(dirname(dst), noThrow)) throw er;
+        downgrade(code);
+      } else if (code === "EXDEV" || code === "EPERM" || code === "EACCES" || code === "ENOTSUP") {
+        downgrade(code);
+      } else if (code !== "EMLINK") {
+        throw er;
+      }
+    }
+  }
+  let body;
+  try {
+    body = readFileSync(src);
+  } catch (er) {
+    if (er.code === "ENOENT") return false;
+    throw er;
+  }
+  writeFileSync(dst, body, { mode: exec ? 511 : 438, flag: "wx" });
+  if (exec) chmodSync(dst, statSync(src).mode & 511);
+  return "copy";
+};
+var fill = (storeEntry, tmp, index, copy) => {
+  const put = ([p, , exec]) => place(
+    storeEntry + sep + native(p),
+    tmp + sep + native(p),
+    exec,
+    copy
+  );
+  try {
+    for (const d of index.dirs) mkdirSync(tmp + sep + native(d));
+    let pj;
+    let linked = false;
+    for (const f of index.files) {
+      if (f[0] === "package.json") {
+        pj = f;
+        continue;
+      }
+      const how2 = put(f);
+      if (!how2) return "damaged";
+      if (how2 === "link") linked = true;
+    }
+    if (!pj) return;
+    const how = put(pj);
+    if (!how) return "damaged";
+    if (how === "copy" && linked) return "mixed";
+    if (verify && statSync(tmp + sep + pj[0]).size !== pj[1]) {
+      return "damaged";
+    }
+  } catch (er) {
+    if (er.code === "EEXIST")
+      return "clash";
+    throw er;
+  }
+};
+var linkFromStore = (storeEntry, target, { copy = false, clone = false } = {}) => {
+  if (clone && cloneNone) return false;
+  const index = readStoreIndex(storeEntry);
+  if (!index || !lstatSync(storeEntry, noThrow)?.isDirectory()) {
+    return false;
+  }
+  const parent = lstatSync(dirname(target), noThrow);
+  if (parent?.isSymbolicLink()) return false;
+  if (!parent) mkdirSync(dirname(target), { recursive: true });
+  const tmp = tmpName(target);
+  const og = tmp + ".ORIGINAL";
+  let succeeded = false;
+  try {
+    if (clone && !cloneEntry(storeEntry, tmp)) return false;
+    let copied = !clone && copy;
+    if (!clone) mkdirSync(tmp);
+    let miss = clone ? checkClone(tmp, index) : fill(storeEntry, tmp, index, copied);
+    if (miss === "mixed") {
+      rimrafSync(tmp);
+      mkdirSync(tmp);
+      copied = true;
+      miss = fill(storeEntry, tmp, index, copied);
+    }
+    if (miss === "clash") {
+      debug("global store: name clash in target", storeEntry);
+      return false;
+    }
+    if (miss) {
+      debug("global store: removing damaged entry", storeEntry);
+      try {
+        removeStoreEntry(storeEntry);
+      } catch {
+      }
+      return false;
+    }
+    const targetExists = !!lstatSync(target, noThrow);
+    if (targetExists) renameSync(target, og);
+    renameSync(tmp, target);
+    if (targetExists) rimrafSync(og);
+    if (clone || copied || copyAll || index.scripts) {
+      markStoreEntryCopied(storeEntry);
+    }
+    succeeded = true;
+    return {
+      how: clone ? "clone" : copied || copyAll ? "copy" : "link",
+      index
+    };
+  } finally {
+    if (!succeeded) {
+      if (lstatSync(og, noThrow)) {
+        rimrafSync(target);
+        renameSync(og, target);
+      }
+      rimrafSync(tmp);
+    }
+  }
+};
+
+// ../../src/tar/src/placement-pool.ts
+import { availableParallelism } from "node:os";
+import { Worker } from "node:worker_threads";
+
+// ../../src/tar/src/placement-worker.ts
+import { resolve } from "node:path";
+var __CODE_SPLIT_SCRIPT_NAME = resolve(import.meta.dirname, "tar-src-placement-worker.js");
+
+// ../../src/tar/src/placement-pool.ts
+var placementThreads = () => {
+  const env = process.env.VLT_PLACEMENT_THREADS;
+  if (env !== void 0 && env !== "") {
+    const n = Number(env);
+    return Number.isInteger(n) && n >= 1 ? n : 1;
+  }
+  return Math.min(Math.max(availableParallelism() - 1, 1), 8);
+};
+var DEFAULT_PLACEMENT_MIN_JOBS = 100;
+var DEFAULT_HELD_BYTES = 64 * 1024 * 1024;
+var PlacementPool = class {
+  #size;
+  #minJobs;
+  #heldMax;
+  #workers = [];
+  #ready = /* @__PURE__ */ new Set();
+  #idle = [];
+  #queue = [];
+  #pending = /* @__PURE__ */ new Map();
+  #seq = 0;
+  #seen = 0;
+  #started = false;
+  #threaded = false;
+  #closed = false;
+  #booting = [];
+  #held = 0;
+  #room = [];
+  #busy = 0;
+  #queued = 0;
+  constructor(size = placementThreads(), minJobs = DEFAULT_PLACEMENT_MIN_JOBS, heldMax = DEFAULT_HELD_BYTES) {
+    this.#size = size;
+    this.#minJobs = minJobs;
+    this.#heldMax = heldMax;
+  }
+  /** True when placement runs inline, with no worker threads. */
+  get inline() {
+    return this.#size < 2;
+  }
+  /** True once the workers were started and placement goes to them. */
+  get threaded() {
+    return this.#threaded;
+  }
+  // Whether a placement arriving now runs on the main thread: no
+  // workers at all, closed, or not (or no longer) threaded. A method,
+  // not a getter, so a re-check after an await is not narrowed away.
+  #inlineNow() {
+    return this.inline || this.#closed || !this.#threaded;
+  }
+  /** Number of worker threads spawned so far (for tests). */
+  get workerCount() {
+    return this.#workers.length;
+  }
+  /** Number of workers that have booted and can take jobs (for tests). */
+  get readyCount() {
+    return this.#ready.size;
+  }
+  /** Compressed bytes downloaded and waiting for, or in, an unpack. */
+  get heldBytes() {
+    return this.#held;
+  }
+  /**
+   * Start the workers for an install that will place `jobs` packages,
+   * so they boot now rather than when the first placement arrives.
+   * Starts nothing, leaving placement inline, when the pool is inline
+   * or closed, when it was already warmed, or when `jobs` is below the
+   * minimum. Resolves once every worker it started is ready or gone; it
+   * never rejects, so a caller may fire and forget it.
+   */
+  async warm(jobs) {
+    if (this.inline || this.#closed || this.#threaded || jobs < this.#minJobs) {
+      return;
+    }
+    this.#threaded = true;
+    this.#started = true;
+    try {
+      while (this.#workers.length < this.#size) this.#spawn();
+    } catch {
+      if (!this.#workers.length) {
+        this.#threaded = false;
+        return;
+      }
+    }
+    await new Promise((resolve2) => {
+      this.#booting.push(resolve2);
+      this.#checkBooted();
+    });
+  }
+  // A pool nobody warmed starts itself once enough placements have
+  // come through to pay for the boot. The placements before that ran
+  // inline; the ones from here on queue for the workers. Workers that
+  // were started once and all died are not started again: the pool
+  // stays inline, as it would after a `warm`.
+  #maybeAutoWarm() {
+    if (this.#started || this.#closed || this.inline) return;
+    if (++this.#seen < this.#minJobs) return;
+    void this.warm(this.#seen);
+  }
+  // Every live worker is ready, or none is left: settle any warm() that
+  // is waiting on the boot.
+  #checkBooted() {
+    if (this.#ready.size < this.#workers.length) return;
+    const waiters = this.#booting;
+    this.#booting = [];
+    for (const resolve2 of waiters) resolve2();
+  }
+  /**
+   * Unpack `tarData` into `target`: on a worker once the pool is
+   * threaded, inline otherwise (inflating on libuv's threadpool and
+   * writing on the main thread, as before this pool existed). Resolves
+   * when the files are in place.
+   *
+   * The bytes are copied before they go to a worker: the caller may
+   * still hold them (the registry client caches its response bodies),
+   * and a transfer would detach them for everyone. For a tarball that
+   * is already on disk, {@link unpackCacheEntry} avoids the copy.
+   */
+  async unpack(tarData, target, format) {
+    this.#maybeAutoWarm();
+    if (this.#inlineNow())
+      return unpackParallel(tarData, target, format);
+    const bytes = tarData.byteLength;
+    await this.#reserve(bytes);
+    if (this.#inlineNow()) {
+      this.#release(bytes);
+      return unpackParallel(tarData, target, format);
+    }
+    const copy = new Uint8Array(bytes);
+    copy.set(tarData);
+    await this.#submit(
+      {
+        kind: "unpack",
+        id: this.#seq++,
+        buffer: copy.buffer,
+        byteOffset: 0,
+        byteLength: bytes,
+        target,
+        format
+      },
+      bytes
+    );
+  }
+  /**
+   * Unpack the tarball in the vlt cache entry `file` into `target`. A
+   * worker reads the file itself, so the main thread neither reads nor
+   * copies the body, and nothing is held against the byte cap. Inline
+   * when the pool is not threaded, like {@link unpack}.
+   */
+  async unpackCacheEntry(file, target, format) {
+    this.#maybeAutoWarm();
+    if (this.#inlineNow()) {
+      return unpackCacheEntryParallel(file, target, format);
+    }
+    await this.#submit(
+      { kind: "cacheEntry", id: this.#seq++, file, target, format },
+      0
+    );
+  }
+  // Wait until `bytes` more may be held. Nothing waits while nothing is
+  // held, so one oversized tarball never deadlocks.
+  async #reserve(bytes) {
+    while (this.#held > 0 && this.#held + bytes > this.#heldMax) {
+      await new Promise((resolve2) => this.#room.push(resolve2));
+    }
+    this.#held += bytes;
+  }
+  #release(bytes) {
+    this.#held -= bytes;
+    const waiters = this.#room;
+    this.#room = [];
+    for (const resolve2 of waiters) resolve2();
+  }
+  // Queue the job, or hand it to a free worker. A ready worker is free:
+  // use it. Otherwise queue; a worker takes the next queued job as it
+  // finishes, or as it finishes booting. Placing inline while the
+  // workers boot was measured and rejected: on a machine with few cores
+  // the main thread's placement contends with the boots, and the install
+  // comes out slower than either.
+  #submit(job, bytes) {
+    return new Promise((resolve2, reject) => {
+      this.#pending.set(job.id, { bytes, resolve: resolve2, reject });
+      const worker = this.#idle.pop();
+      if (worker) this.#assign(worker, job);
+      else {
+        this.#queue.push(job);
+        this.#queued++;
+        this.#trace();
+      }
+    });
+  }
+  #trace() {
+    lane("unpack", this.#busy, this.#queued);
+  }
+  #spawn() {
+    trace("pool:spawn", { workers: this.#workers.length + 1 });
+    const worker = new Worker(__CODE_SPLIT_SCRIPT_NAME);
+    worker.on(
+      "message",
+      (reply) => this.#onMessage(worker, reply)
+    );
+    worker.on("error", (er) => this.#onLost(worker, er));
+    worker.on(
+      "exit",
+      () => this.#onLost(worker, new Error("placement worker exited"))
+    );
+    this.#workers.push(worker);
+  }
+  #assign(worker, job) {
+    const pending = this.#pending.get(job.id);
+    if (pending) pending.worker = worker;
+    this.#busy++;
+    this.#trace();
+    worker.ref();
+    worker.postMessage(job, job.kind === "unpack" ? [job.buffer] : []);
+  }
+  // Hand the worker the next queued job, or park it idle.
+  #park(worker) {
+    const next = this.#queue.shift();
+    if (next) {
+      this.#queued--;
+      this.#assign(worker, next);
+    } else {
+      worker.unref();
+      this.#idle.push(worker);
+    }
+  }
+  #settle(id, pending) {
+    if (pending.worker) {
+      this.#busy--;
+      this.#trace();
+    }
+    this.#release(pending.bytes);
+    this.#pending.delete(id);
+  }
+  #onMessage(worker, reply) {
+    if ("ready" in reply) {
+      this.#ready.add(worker);
+      trace("pool:ready", { ready: this.#ready.size });
+      this.#park(worker);
+      this.#checkBooted();
+      return;
+    }
+    const pending = this.#pending.get(reply.id);
+    if (pending) this.#settle(reply.id, pending);
+    this.#park(worker);
+    if (!pending) return;
+    if ("result" in reply) pending.resolve();
+    else {
+      const er = new Error(reply.error);
+      er.stack = reply.stack ?? er.stack;
+      if (reply.code !== void 0) er.code = reply.code;
+      pending.reject(er);
+    }
+  }
+  // A worker died outright, not a job that threw (that comes back as a
+  // reply). Drop it, reject the one job it was running, and keep the
+  // queue moving so no placement promise is left hanging. 'error' and
+  // 'exit' both land here, so the first call drops the worker and the
+  // second returns.
+  #onLost(worker, er) {
+    if (!this.#workers.includes(worker)) return;
+    this.#workers = this.#workers.filter((w) => w !== worker);
+    this.#idle = this.#idle.filter((w) => w !== worker);
+    this.#ready.delete(worker);
+    for (const [id, pending] of this.#pending) {
+      if (pending.worker === worker) {
+        this.#settle(id, pending);
+        pending.reject(er);
+      }
+    }
+    this.#checkBooted();
+    if (this.#workers.length) return;
+    this.#threaded = false;
+    this.#rejectQueued(er);
+  }
+  #rejectQueued(er) {
+    const queued = this.#queue;
+    this.#queue = [];
+    for (const job of queued) {
+      this.#queued--;
+      const pending = this.#pending.get(job.id);
+      if (pending) {
+        this.#settle(job.id, pending);
+        pending.reject(er);
+      }
+    }
+  }
+  /**
+   * Terminate every worker. Safe to call more than once. Any placement
+   * still assigned or queued is rejected rather than left hanging, since
+   * terminating a worker stops it before it can reply, and a `warm()`
+   * still waiting on the boot is released.
+   */
+  async close() {
+    this.#closed = true;
+    this.#threaded = false;
+    const workers = this.#workers;
+    this.#workers = [];
+    this.#idle = [];
+    this.#ready.clear();
+    const er = new Error("placement pool closed");
+    this.#rejectQueued(er);
+    for (const [id, pending] of this.#pending) {
+      this.#settle(id, pending);
+      pending.reject(er);
+    }
+    this.#checkBooted();
+    await Promise.all(workers.map((w) => w.terminate()));
+  }
+};
+
+// ../../src/tar/src/pool.ts
+import { readFile } from "node:fs/promises";
+var mode = process.env.VLT_TAR_SYNC;
+var Pool = class {
+  #placement;
+  get #pool() {
+    this.#placement ??= new PlacementPool();
+    return this.#placement;
+  }
+  /**
+   * Provide the tardata to be unpacked, and the location where it's to be
+   * placed. Resolves when the tarball has been extracted. See
+   * {@link PlacementPool.unpack}.
+   */
+  async unpack(tarData, target, format) {
+    if (mode === "0") return unpack(tarData, target, format);
+    if (mode === "1") return unpackSync(tarData, target, format);
+    return this.#pool.unpack(tarData, target, format);
+  }
+  /**
+   * Unpack the tarball in the vlt cache entry `file`, whose first 4
+   * bytes are the big-endian length of the head before the body. On a
+   * worker the file is read there, so the main thread never holds the
+   * body. See {@link PlacementPool.unpackCacheEntry}.
+   */
+  async unpackCacheEntry(file, target, format) {
+    if (mode === "0") {
+      return unpack(
+        cacheEntryBody(await readFile(file)),
+        target,
+        format
+      );
+    }
+    if (mode === "1")
+      return unpackCacheEntrySync(file, target, format);
+    return this.#pool.unpackCacheEntry(file, target, format);
+  }
+  /**
+   * Same, reading the tarball from a file and skipping `offset` leading
+   * bytes, so a cache entry is unpacked without loading it into the
+   * registry client's in-memory cache.
+   */
+  async unpackFile(file, target, offset = 0, format) {
+    if (mode === "0") {
+      return unpack(
+        (await readFile(file)).subarray(offset),
+        target,
+        format
+      );
+    }
+    if (mode === "1") {
+      return unpackFileSync(file, target, offset, format);
+    }
+    return unpackFileParallel(file, target, offset, format);
+  }
+  /**
+   * Hardlink (or copy) a global store entry into `target`. Resolves
+   * how, with the index, or false on a store miss. See
+   * {@link linkFromStore}.
+   */
+  async linkFromStore(storeEntry, target, opts) {
+    return linkFromStore(storeEntry, target, opts);
+  }
+  /**
+   * Start the unpack workers for an install about to unpack `jobs`
+   * tarballs, so they boot while the first packages are fetched rather
+   * than on the first placement. Never rejects. See
+   * {@link PlacementPool.warm}.
+   */
+  async warm(jobs) {
+    if (mode !== void 0) return;
+    await this.#pool.warm(jobs);
+  }
+  /**
+   * Terminate the placement worker threads, if any were started. The
+   * pool works without this -- idle workers do not keep the process
+   * alive -- but reify calls it when an install's placement is done, to
+   * free the threads promptly.
+   */
+  async close() {
+    await this.#placement?.close();
+  }
+  /**
+   * Explode a tarball into `dir` for the global store. See
+   * {@link unpackToStoreSync}.
+   */
+  async unpackToStore(tarData, dir, format) {
+    return unpackToStoreSync(tarData, dir, format);
+  }
+};
+export {
+  DEFAULT_HELD_BYTES,
+  DEFAULT_PLACEMENT_MIN_JOBS,
+  PlacementPool,
+  Pool,
+  cloneAvailable,
+  linkFromStore,
+  markStoreEntryCopied,
+  placementThreads,
+  readStoreIndex,
+  removeStoreEntry,
+  storeCopiedPath,
+  storeEntryCopied,
+  storeEntryLastCopied,
+  storeEntryLinked,
+  storeEntryNames,
+  storeEntryTime,
+  storeIndexPath,
+  unpack,
+  unpackToStoreSync,
+  verifyStoreEntry
+};

package/{src-A5ZJNOHN.js → src-REZNPR2X.js}

@@ -29,11 +29,11 @@ import {
   runtimeTokens,
   setRuntimeToken,
   setToken
-} from "./chunk-Q2UEILN6.js";
+} from "./chunk-NB7QVWHU.js";
 import "./chunk-QNHBAGXQ.js";
 import {
   userAgent
-} from "./chunk-M242QVJS.js";
+} from "./chunk-HHSPE2DS.js";
 import {
   assertOk,
   registryErrorMessage,
@@ -41,10 +41,10 @@ import {
   storeRoot
 } from "./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-LEMHGORE.js";
+import "./chunk-6ETYWCJN.js";
 import "./chunk-BF5DRGRZ.js";
 import "./chunk-WZWDS3W4.js";
 import "./chunk-PZLD7RTK.js";